diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 83330bdf54..c11b8f2803 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -56,3 +56,17 @@ jobs:
         config: '.markdownlint.json'
         globs: |
           **/*.md
+
+    - name: Setup Node
+      uses: actions/setup-node@2028fbc5c25fe9cf00d9f06a71cc4710d4507903 # v6.0.0
+      with:
+        node-version: '24.x'
+
+    - name: Install Spectral
+      run: npm install --global "@stoplight/spectral-cli@${SPECTRAL_VERSION}"
+      env:
+        # renovate: datasource=npm packageName=@stoplight/spectral-cli
+        SPECTRAL_VERSION: '6.15.0'
+
+    - name: Run Spectral
+      run: spectral lint "./test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/*" --display-only-failures --fail-severity error --format github-actions
diff --git a/.spectral.yaml b/.spectral.yaml
new file mode 100644
index 0000000000..7d9855d6a6
--- /dev/null
+++ b/.spectral.yaml
@@ -0,0 +1 @@
+extends: ['spectral:oas']
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 499bc1f00a..1b60a12dfd 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -15,6 +15,7 @@
     <PackageVersion Include="Microsoft.AspNetCore.TestHost" Version="8.0.22" />
     <PackageVersion Include="Microsoft.Build" Version="18.0.2" />
     <PackageVersion Include="Microsoft.CodeAnalysis.PublicApiAnalyzers" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.0" />
     <PackageVersion Include="Microsoft.Kiota.Bundle" Version="1.21.0" />
     <PackageVersion Include="Microsoft.OpenApi" Version="2.3.9" />
     <PackageVersion Include="Microsoft.OpenApi.YamlReader" Version="2.3.9" />
@@ -22,6 +23,7 @@
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="MSBuild.ProjectCreation" Version="17.0.1" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
+    <PackageVersion Include="NJsonSchema" Version="11.5.2" />
     <PackageVersion Include="NSubstitute" Version="5.3.0" />
     <PackageVersion Include="NSwag.CodeGeneration.CSharp" Version="14.6.3" />
     <PackageVersion Include="NSwag.MSBuild" Version="14.6.3" />
diff --git a/Swashbuckle.AspNetCore.slnx b/Swashbuckle.AspNetCore.slnx
index 4e75d24a73..5ba846053c 100644
--- a/Swashbuckle.AspNetCore.slnx
+++ b/Swashbuckle.AspNetCore.slnx
@@ -77,6 +77,7 @@
     <Project Path="test/WebSites/ReDoc/ReDoc.csproj" />
     <Project Path="test/WebSites/TestFirst.IntegrationTests/TestFirst.IntegrationTests.csproj" />
     <Project Path="test/WebSites/TestFirst/TestFirst.csproj" />
+    <Project Path="test/WebSites/TodoApp/TodoApp.csproj" />
     <Project Path="test/WebSites/TopLevelSwaggerDoc/TopLevelSwaggerDoc.csproj" />
     <Project Path="test/WebSites/WebApi.Aot/WebApi.Aot.csproj" />
     <Project Path="test/WebSites/WebApi/WebApi.csproj" />
diff --git a/src/Swashbuckle.AspNetCore.SwaggerGen/SchemaGenerator/SchemaGenerator.cs b/src/Swashbuckle.AspNetCore.SwaggerGen/SchemaGenerator/SchemaGenerator.cs
index f76d8cfd9a..acc20e3d70 100644
--- a/src/Swashbuckle.AspNetCore.SwaggerGen/SchemaGenerator/SchemaGenerator.cs
+++ b/src/Swashbuckle.AspNetCore.SwaggerGen/SchemaGenerator/SchemaGenerator.cs
@@ -66,22 +66,10 @@ private IOpenApiSchema GenerateSchemaForMember(
             {
                 var requiredAttribute = customAttributes.OfType<RequiredAttribute>().FirstOrDefault();
 
-                var nullable = IsNullable(requiredAttribute, dataProperty, memberInfo);
-
-                if (usingAllOf)
-                {
-                    // When using AllOf to extend reference schemas, we need to adjust the schema to represent
-                    // nullability correctly as a property can't be null AND a specific type at the same time.
-                    // See https://github.com/domaindrivendev/Swashbuckle.AspNetCore/issues/3649.
-                    if (nullable)
-                    {
-                        concrete.OneOf = schema.AllOf;
-                        concrete.OneOf.Add(new OpenApiSchema { Type = JsonSchemaType.Null });
-                        concrete.AllOf = null;
-                    }
-                }
-                else
+                // "nullable" cannot be used without "type"
+                if (!usingAllOf)
                 {
+                    var nullable = IsNullable(requiredAttribute, dataProperty, memberInfo);
                     SetNullable(concrete, nullable);
                 }
 
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/ClientGenerator.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/ClientGenerator.cs
index 6748caf788..2bc79a1f29 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/ClientGenerator.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/ClientGenerator.cs
@@ -73,22 +73,30 @@ public async Task CompileAsync(string location)
 
     public async Task<TemporaryDirectory> GenerateFromStringAsync(ClientGeneratorTool generator, string openApiDocument)
     {
-        TemporaryDirectory project;
+        TemporaryDirectory project = null;
 
-        switch (generator)
+        try
+        {
+            switch (generator)
+            {
+                case ClientGeneratorTool.Kiota:
+                    project = await GenerateProjectAsync(["Microsoft.Kiota.Bundle"]);
+                    await GenerateClientFromStringWithKiotaAsync(project.Path, openApiDocument, outputHelper);
+                    break;
+
+                case ClientGeneratorTool.NSwag:
+                    project = await GenerateProjectAsync(["Newtonsoft.Json"]);
+                    await GenerateClientFromStringWithNSwagAsync(project.Path, openApiDocument);
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(generator), generator, $"The client generator tool '{generator}' is not supported.");
+            }
+        }
+        catch (Exception)
         {
-            case ClientGeneratorTool.Kiota:
-                project = await GenerateProjectAsync(["Microsoft.Kiota.Bundle"]);
-                await GenerateClientFromStringWithKiotaAsync(project.Path, openApiDocument, outputHelper);
-                break;
-
-            case ClientGeneratorTool.NSwag:
-                project = await GenerateProjectAsync(["Newtonsoft.Json"]);
-                await GenerateClientFromStringWithNSwagAsync(project.Path, openApiDocument);
-                break;
-
-            default:
-                throw new ArgumentOutOfRangeException(nameof(generator), generator, $"The client generator tool '{generator}' is not supported.");
+            project?.Dispose();
+            throw;
         }
 
         return project;
@@ -96,22 +104,30 @@ public async Task<TemporaryDirectory> GenerateFromStringAsync(ClientGeneratorToo
 
     public async Task<TemporaryDirectory> GenerateFromUrlAsync(ClientGeneratorTool generator, string openApiDocumentUrl)
     {
-        TemporaryDirectory project;
+        TemporaryDirectory project = null;
 
-        switch (generator)
+        try
+        {
+            switch (generator)
+            {
+                case ClientGeneratorTool.Kiota:
+                    project = await GenerateProjectAsync(["Microsoft.Kiota.Bundle"]);
+                    await GenerateClientFromUrlWithKiotaAsync(project.Path, openApiDocumentUrl, outputHelper);
+                    break;
+
+                case ClientGeneratorTool.NSwag:
+                    project = await GenerateProjectAsync(["Newtonsoft.Json"]);
+                    await GenerateClientFromUrlWithNSwagAsync(project.Path, openApiDocumentUrl);
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(generator), generator, $"The client generator tool '{generator}' is not supported.");
+            }
+        }
+        catch (Exception)
         {
-            case ClientGeneratorTool.Kiota:
-                project = await GenerateProjectAsync(["Microsoft.Kiota.Bundle"]);
-                await GenerateClientFromUrlWithKiotaAsync(project.Path, openApiDocumentUrl, outputHelper);
-                break;
-
-            case ClientGeneratorTool.NSwag:
-                project = await GenerateProjectAsync(["Newtonsoft.Json"]);
-                await GenerateClientFromUrlWithNSwagAsync(project.Path, openApiDocumentUrl);
-                break;
-
-            default:
-                throw new ArgumentOutOfRangeException(nameof(generator), generator, $"The client generator tool '{generator}' is not supported.");
+            project?.Dispose();
+            throw;
         }
 
         return project;
@@ -283,7 +299,7 @@ private static string GetNuGetPackageVersion(string name)
         var ns = project.Root.GetDefaultNamespace();
 
         var version = project
-            .Root?
+            .Root
             .Elements(ns + "ItemGroup")
             .Elements(ns + "PackageVersion")
             .Select((p) =>
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/CodeGenerationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/CodeGenerationTests.cs
index d79992ee1a..1c556d9279 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/CodeGenerationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/CodeGenerationTests.cs
@@ -1,8 +1,14 @@
 #if NET10_0_OR_GREATER
 
 using System.Reflection;
-using System.Text.Json;
+using System.Security.Cryptography;
+using System.Text;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Kiota.Abstractions.Authentication;
+using Microsoft.Kiota.Http.HttpClientLibrary;
 using Microsoft.OpenApi;
+using TodoApp.Client;
+using TodoApp.Client.Models;
 
 namespace Swashbuckle.AspNetCore.IntegrationTests;
 
@@ -15,28 +21,17 @@ public static TheoryData<ClientGeneratorTool, string> SnapshotTestCases()
     {
         var testCases = new TheoryData<ClientGeneratorTool, string>();
         
-        foreach (var path in Directory.EnumerateFiles(Path.Combine(GetProjectRoot(), "snapshots"), "*.txt", SearchOption.AllDirectories))
+        foreach (var testCase in SnapshotTestData.Snapshots())
         {
+            var path = testCase.Data.Item1;
+            var documentVersion = testCase.Data.Item2;
+
             // Deduplicate by ignoring snapshots for other TFMs
             if (!path.EndsWith(".DotNet10_0.verified.txt", StringComparison.Ordinal))
             {
                 continue;
             }
 
-            using var snapshot = File.OpenRead(path);
-            using var document = JsonDocument.Parse(snapshot);
-
-            if (!document.RootElement.TryGetProperty("openapi", out var property) &&
-                !document.RootElement.TryGetProperty("swagger", out property))
-            {
-                continue;
-            }
-
-            if (!Version.TryParse(property.GetString(), out var documentVersion))
-            {
-                continue;
-            }
-
             var version = documentVersion switch
             {
                 { Major: 2 } => OpenApiSpecVersion.OpenApi2_0,
@@ -65,16 +60,284 @@ public static TheoryData<ClientGeneratorTool, string> SnapshotTestCases()
 
     [Theory]
     [MemberData(nameof(SnapshotTestCases))]
-    public async Task OpenApiDocument_Generates_Valid_Client_Code_From_Snapshot(ClientGeneratorTool tool, string path)
+    public async Task GeneratesValidClient(ClientGeneratorTool tool, string snapshot)
     {
         // Arrange
         var generator = new ClientGenerator(outputHelper);
-        var document = await File.ReadAllTextAsync(path, TestContext.Current.CancellationToken);
+        var snapshotPath = Path.Combine(SnapshotTestData.SnapshotsPath(), snapshot);
+
+        var document = await File.ReadAllTextAsync(snapshotPath, TestContext.Current.CancellationToken);
 
         using var project = await generator.GenerateFromStringAsync(tool, document);
 
         // Act and Assert
         await generator.CompileAsync(project.Path);
+
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes($"{tool}:{snapshot}"));
+        var hashString = Convert.ToHexString(hash).ToLowerInvariant()[..16];
+
+        outputHelper.WriteLine($"{nameof(tool)}={tool}, {nameof(snapshot)}={snapshot} [{hashString}]");
+
+        await VerifyDirectory(
+            project.Path,
+            pattern: "*.cs",
+            include: (p) => !p.Contains("bin") && !p.Contains("obj"),
+            options: new() { RecurseSubdirectories = true })
+            .UseDirectory("snapshots")
+            .UseFileName($"{nameof(GeneratesValidClient)}_{hashString}");
+    }
+
+    [Fact]
+    public async Task Can_Manage_Todo_Items_With_Api()
+    {
+        // Arrange
+        await WithTodoAppClientAsync(async (client) =>
+        {
+            var cancellationToken = TestContext.Current.CancellationToken;
+
+            // Act - Get all the items
+            var items = await client.Api.Items.GetAsync(cancellationToken: cancellationToken);
+
+            // Assert - There should be no items
+            Assert.NotNull(items);
+            Assert.NotNull(items.Items);
+
+            var beforeCount = items.Items.Count;
+
+            // Arrange
+            var text = "Buy eggs";
+
+            // Act - Add a new item
+            var createdItem = await client.Api.Items.PostAsync(
+                new() { Text = text },
+                cancellationToken: cancellationToken);
+
+            // Assert - An item was created
+            Assert.NotNull(createdItem);
+            Assert.NotEqual(default, createdItem.Id);
+
+            // Arrange - Get the new item's URL and Id
+            var itemId = createdItem.Id;
+
+            // Act - Get the item
+            var item = await client.Api.Items[new(itemId)].GetAsync(cancellationToken: cancellationToken);
+
+            // Assert - Verify the item was created correctly
+            Assert.NotNull(item);
+            Assert.Equal(itemId, item.Id);
+            Assert.Null(item.CompletedAt);
+            Assert.NotEqual(default, item.CreatedAt);
+            Assert.Equal(item.CreatedAt.Value, item.LastUpdated);
+            Assert.Null(item.Priority);
+            Assert.Equal(text, item.Text);
+
+            // Act - Update the item to be high priority
+            await client.Api.Items[new(itemId)].Priority.PatchAsync(
+                new() { Priority = TodoPriority.High },
+                cancellationToken: cancellationToken);
+
+            item = await client.Api.Items[new(itemId)].GetAsync(cancellationToken: cancellationToken);
+
+            Assert.NotNull(item);
+            Assert.Equal(itemId, item.Id);
+            Assert.Null(item.CompletedAt);
+            Assert.NotEqual(default, item.CreatedAt);
+            Assert.Equal(item.CreatedAt.Value, item.LastUpdated);
+            Assert.Equal(TodoPriority.High, item.Priority);
+            Assert.Equal(text, item.Text);
+
+            // Act - Mark the item as being completed
+            await client.Api.Items[new(itemId)].Complete.PostAsync(cancellationToken: cancellationToken);
+
+            item = await client.Api.Items[new(itemId)].GetAsync(cancellationToken: cancellationToken);
+
+            Assert.NotNull(item);
+            Assert.Equal(itemId, item.Id);
+            Assert.Equal(text, item.Text);
+            Assert.NotNull(item.CompletedAt);
+            Assert.Equal(item.CompletedAt.Value, item.LastUpdated);
+            Assert.True(item.CompletedAt.Value > item.CreatedAt);
+
+            // Act - Get all the items
+            items = await client.Api.Items.GetAsync(cancellationToken: cancellationToken);
+
+            // Assert - The item was completed
+            Assert.NotNull(items);
+            Assert.NotNull(items.Items);
+            Assert.Equal(beforeCount + 1, items.Items.Count);
+            Assert.Contains(items.Items, (x) => x.Id == itemId);
+
+            item = items.Items.Last();
+
+            Assert.NotNull(item);
+            Assert.Equal(itemId, item.Id);
+            Assert.Equal(text, item.Text);
+            Assert.NotNull(item.CompletedAt);
+            Assert.Equal(item.CompletedAt.Value, item.LastUpdated);
+            Assert.True(item.CompletedAt.Value > item.CreatedAt);
+
+            // Act - Delete the item
+            await client.Api.Items[new(itemId)].DeleteAsync(cancellationToken: cancellationToken);
+
+            // Assert - The item no longer exists
+            items = await client.Api.Items.GetAsync(cancellationToken: cancellationToken);
+
+            Assert.NotNull(items);
+            Assert.NotNull(items.Items);
+            Assert.Equal(beforeCount, items.Items.Count);
+            Assert.DoesNotContain(items.Items, (x) => x.Id == itemId);
+
+            // Act
+            var problem = await Assert.ThrowsAsync<ProblemDetails>(
+                () => client.Api.Items[new(itemId)].GetAsync(cancellationToken: cancellationToken));
+
+            // Assert
+            Assert.NotNull(problem);
+            Assert.Equal(StatusCodes.Status404NotFound, problem.Status);
+            Assert.Equal("Not Found", problem.Title);
+            Assert.Equal("Item not found.", problem.Detail);
+            Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.5", problem.Type);
+            Assert.Null(problem.Instance);
+
+            // Act
+            problem = await Assert.ThrowsAsync<ProblemDetails>(
+                () => client.Api.Items[new(itemId)].Complete.PostAsync(cancellationToken: cancellationToken));
+
+            // Assert
+            Assert.NotNull(problem);
+            Assert.Equal(StatusCodes.Status404NotFound, problem.Status);
+            Assert.Equal("Not Found", problem.Title);
+            Assert.Equal("Item not found.", problem.Detail);
+            Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.5", problem.Type);
+            Assert.Null(problem.Instance);
+
+            // Act
+            problem = await Assert.ThrowsAsync<ProblemDetails>(
+                () => client.Api.Items[new(itemId)].Priority.PatchAsync(new() { Priority = TodoPriority.Low }, cancellationToken: cancellationToken));
+
+            // Assert
+            Assert.NotNull(problem);
+            Assert.Equal(StatusCodes.Status404NotFound, problem.Status);
+            Assert.Equal("Not Found", problem.Title);
+            Assert.Equal("Item not found.", problem.Detail);
+            Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.5", problem.Type);
+            Assert.Null(problem.Instance);
+        });
+    }
+
+    [Fact]
+    public async Task Cannot_Create_Todo_Item_With_No_Text()
+    {
+        // Arrange
+        await WithTodoAppClientAsync(async (client) =>
+        {
+            var cancellationToken = TestContext.Current.CancellationToken;
+
+            // Act
+            var problem = await Assert.ThrowsAsync<ProblemDetails>(
+                () => client.Api.Items.PostAsync(new() { Text = string.Empty }, cancellationToken: cancellationToken));
+
+            // Assert
+            Assert.NotNull(problem);
+            Assert.Equal(StatusCodes.Status400BadRequest, problem.Status);
+            Assert.Equal("Bad Request", problem.Title);
+            Assert.Equal("No item text specified.", problem.Detail);
+            Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", problem.Type);
+            Assert.Null(problem.Instance);
+        });
+    }
+
+    [Fact]
+    public async Task Cannot_Complete_Todo_Item_Multiple_Times()
+    {
+        // Arrange
+        await WithTodoAppClientAsync(async (client) =>
+        {
+            var cancellationToken = TestContext.Current.CancellationToken;
+
+            var createdItem = await client.Api.Items.PostAsync(
+                new() { Text = "Something" },
+                cancellationToken: cancellationToken);
+
+            await client.Api.Items[new(createdItem.Id)].Complete.PostAsync(cancellationToken: cancellationToken);
+
+            // Act
+            var problem = await Assert.ThrowsAsync<ProblemDetails>(
+                () => client.Api.Items[new(createdItem.Id)].Complete.PostAsync(cancellationToken: cancellationToken));
+
+            // Assert
+            Assert.NotNull(problem);
+            Assert.Equal(StatusCodes.Status400BadRequest, problem.Status);
+            Assert.Equal("Bad Request", problem.Title);
+            Assert.Equal("Item already completed.", problem.Detail);
+            Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", problem.Type);
+            Assert.Null(problem.Instance);
+        });
+    }
+
+    [Fact]
+    public async Task Cannot_Complete_Deleted_Todo_Item()
+    {
+        // Arrange
+        await WithTodoAppClientAsync(async (client) =>
+        {
+            var cancellationToken = TestContext.Current.CancellationToken;
+
+            var createdItem = await client.Api.Items.PostAsync(
+                new() { Text = "Something" },
+                cancellationToken: cancellationToken);
+
+            await client.Api.Items[new(createdItem.Id)].DeleteAsync(cancellationToken: cancellationToken);
+
+            // Act
+            var problem = await Assert.ThrowsAsync<ProblemDetails>(
+                () => client.Api.Items[new(createdItem.Id)].Complete.PostAsync(cancellationToken: cancellationToken));
+
+            // Assert
+            Assert.NotNull(problem);
+            Assert.Equal(StatusCodes.Status404NotFound, problem.Status);
+            Assert.Equal("Not Found", problem.Title);
+            Assert.Equal("Item not found.", problem.Detail);
+            Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.5", problem.Type);
+            Assert.Null(problem.Instance);
+        });
+    }
+
+    [Fact]
+    public async Task Cannot_Delete_Todo_Item_Multiple_Times()
+    {
+        // Arrange
+        await WithTodoAppClientAsync(async (client) =>
+        {
+            var cancellationToken = TestContext.Current.CancellationToken;
+
+            var createdItem = await client.Api.Items.PostAsync(
+                new() { Text = "Something" },
+                cancellationToken: cancellationToken);
+
+            await client.Api.Items[new(createdItem.Id)].DeleteAsync(cancellationToken: cancellationToken);
+
+            // Act
+            var problem = await Assert.ThrowsAsync<ProblemDetails>(
+                () => client.Api.Items[new(createdItem.Id)].DeleteAsync(cancellationToken: cancellationToken));
+
+            // Assert
+            Assert.NotNull(problem);
+            Assert.Equal(StatusCodes.Status404NotFound, problem.Status);
+            Assert.Equal("Not Found", problem.Title);
+            Assert.Equal("Item not found.", problem.Detail);
+            Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.5", problem.Type);
+            Assert.Null(problem.Instance);
+        });
+    }
+
+    [Fact]
+    public async Task VerifyKiotaTodoAppClient()
+    {
+        await VerifyDirectory(
+            Path.Combine(GetProjectRoot(), "TodoClient"),
+            pattern: "*.cs",
+            options: new() { RecurseSubdirectories = true }).UseDirectory("snapshots");
     }
 
     private static string GetProjectRoot() =>
@@ -82,6 +345,18 @@ private static string GetProjectRoot() =>
             .GetCustomAttributes<AssemblyMetadataAttribute>()
             .First((p) => p.Key is "ProjectRoot")
             .Value!;
+
+    private static async Task WithTodoAppClientAsync(Func<TodoApiClient, Task> callback)
+    {
+        using var httpClient = SwaggerIntegrationTests.GetHttpClientForTestApplication(typeof(TodoApp.Program));
+
+        var provider = new AnonymousAuthenticationProvider();
+        using var request = new HttpClientRequestAdapter(provider, httpClient: httpClient);
+
+        var client = new TodoApiClient(request);
+
+        await callback(client);
+    }
 }
 
 #endif
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SchemaTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SchemaTests.cs
new file mode 100644
index 0000000000..38f9a8b083
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SchemaTests.cs
@@ -0,0 +1,27 @@
+using NJsonSchema;
+
+namespace Swashbuckle.AspNetCore.IntegrationTests;
+
+public class SchemaTests
+{
+    [Theory]
+    [MemberData(nameof(SnapshotTestData.Snapshots), MemberType = typeof(SnapshotTestData))]
+    public async Task OpenApiDocumentsAreValid(string snapshot, Version version)
+    {
+        // Arrange
+        var cancellationToken = TestContext.Current.CancellationToken;
+
+        var schemaPath = Path.Combine(SnapshotTestData.SchemasPath(), $"schema.{version.Major}.{version.Minor}.json");
+        var snapshotPath = Path.Combine(SnapshotTestData.SnapshotsPath(), snapshot);
+
+        var schema = await JsonSchema.FromFileAsync(schemaPath, cancellationToken);
+        var specification = await File.ReadAllTextAsync(snapshotPath, cancellationToken);
+
+        // Act
+        var actual = schema.Validate(specification);
+
+        // Assert
+        Assert.NotNull(actual);
+        Assert.Empty(actual);
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SnapshotTestData.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SnapshotTestData.cs
new file mode 100644
index 0000000000..d4dc311a0a
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SnapshotTestData.cs
@@ -0,0 +1,46 @@
+using System.Reflection;
+using System.Text.Json;
+
+namespace Swashbuckle.AspNetCore.IntegrationTests;
+
+public static class SnapshotTestData
+{
+    private static string _projectRoot =
+        typeof(SnapshotTestData).Assembly
+            .GetCustomAttributes<AssemblyMetadataAttribute>()
+            .First((p) => p.Key is "ProjectRoot")
+            .Value!;
+
+    public static string SnapshotsPath() => Path.Combine(_projectRoot, "snapshots");
+
+    public static string SchemasPath() => Path.Combine(_projectRoot, "schemas");
+
+    public static TheoryData<string, Version> Snapshots()
+    {
+        var testCases = new TheoryData<string, Version>();
+        var snapshotsPath = Path.Combine(_projectRoot, "snapshots");
+
+        foreach (var path in Directory.EnumerateFiles(snapshotsPath, "*.txt", SearchOption.AllDirectories))
+        {
+            using var snapshot = File.OpenRead(path);
+            using var document = JsonDocument.Parse(snapshot);
+
+            if (!document.RootElement.TryGetProperty("openapi", out var property) &&
+                !document.RootElement.TryGetProperty("swagger", out property))
+            {
+                continue;
+            }
+
+            if (!Version.TryParse(property.GetString(), out var version))
+            {
+                continue;
+            }
+
+            var relativePath = Path.GetRelativePath(snapshotsPath, path);
+
+            testCases.Add(relativePath, version);
+        }
+
+        return testCases;
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerIntegrationTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerIntegrationTests.cs
index d992e8261e..bba415e2ef 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerIntegrationTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/SwaggerIntegrationTests.cs
@@ -117,6 +117,7 @@ public async Task SwaggerMiddleware_CanBeConfiguredMultipleTimes(
     [InlineData(typeof(MinimalApp.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(MinimalAppWithNullableEnums.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(MvcWithNullable.Program), "/swagger/v1/swagger.json")]
+    [InlineData(typeof(TodoApp.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(TopLevelSwaggerDoc.Program), "/swagger/v1.json")]
     [InlineData(typeof(WebApi.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(WebApi.Aot.Program), "/swagger/v1/swagger.json")]
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
index a963d5d5eb..c77f8cbb1a 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/Swashbuckle.AspNetCore.IntegrationTests.csproj
@@ -17,21 +17,27 @@
     <PackageReference Include="MartinCostello.Logging.XUnit.v3" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" />
     <PackageReference Include="Microsoft.AspNetCore.TestHost" />
+    <PackageReference Include="Microsoft.Kiota.Bundle" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="Microsoft.OpenApi.YamlReader" />
     <PackageReference Include="Microsoft.Playwright" />
+    <PackageReference Include="NJsonSchema" />
     <PackageReference Include="Verify.XunitV3" />
     <PackageReference Include="xunit.runner.visualstudio" />
     <PackageReference Include="xunit.v3.mtp-off" />
   </ItemGroup>
 
-  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net10.0'))">
+  <ItemGroup>
     <AssemblyMetadata Include="ProjectRoot" Value="$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)'))" />
     <AssemblyMetadata Include="SolutionRoot" Value="$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)\..\..'))" />
-    <ProjectReference Include="..\Swashbuckle.AspNetCore.TestSupport\Swashbuckle.AspNetCore.TestSupport.csproj" />
+    <Compile Remove="snapshots\**\*.cs" />
+  </ItemGroup>
+
+  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net10.0'))">
     <PackageReference Include="Microsoft.Build" />
     <PackageReference Include="MSBuild.ProjectCreation" />
     <PackageReference Include="NSwag.CodeGeneration.CSharp" />
+    <ProjectReference Include="..\Swashbuckle.AspNetCore.TestSupport\Swashbuckle.AspNetCore.TestSupport.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/ApiRequestBuilder.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/ApiRequestBuilder.cs
new file mode 100644
index 0000000000..41b43725aa
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/ApiRequestBuilder.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+using TodoApp.Client.Api.Items;
+namespace TodoApp.Client.Api
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The items property</summary>
+        public global::TodoApp.Client.Api.Items.ItemsRequestBuilder Items
+        {
+            get => new global::TodoApp.Client.Api.Items.ItemsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Find/FindRequestBuilder.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Find/FindRequestBuilder.cs
new file mode 100644
index 0000000000..88a9b963c9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Find/FindRequestBuilder.cs
@@ -0,0 +1,94 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Find
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\find
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FindRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Find.FindRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FindRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/find?IsCompleted={IsCompleted}&Text={Text}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Find.FindRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FindRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/find?IsCompleted={IsCompleted}&Text={Text}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoListViewModel>(requestInfo, global::TodoApp.Client.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Find.FindRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Find.FindRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Find.FindRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class FindRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            /// <summary>Gets or sets a value indicating whether to search completed Todo items.</summary>
+            public bool? IsCompleted { get; set; }
+            /// <summary>Gets or sets the text of the filter.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public string? Text { get; set; }
+#nullable restore
+#else
+            public string Text { get; set; }
+#endif
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/GetAfter/GetAfterRequestBuilder.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/GetAfter/GetAfterRequestBuilder.cs
new file mode 100644
index 0000000000..08a2cd13ad
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/GetAfter/GetAfterRequestBuilder.cs
@@ -0,0 +1,86 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.GetAfter
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\getAfter
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class GetAfterRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetAfterRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/getAfter?value={value}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetAfterRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/getAfter?value={value}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoListViewModel>(requestInfo, global::TodoApp.Client.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class GetAfterRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            [QueryParameter("value")]
+            public DateTimeOffset? Value { get; set; }
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/Complete/CompleteRequestBuilder.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/Complete/CompleteRequestBuilder.cs
new file mode 100644
index 0000000000..d60b464e51
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/Complete/CompleteRequestBuilder.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Item.Complete
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}\complete
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CompleteRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CompleteRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/complete", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CompleteRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/complete", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Marks the todo item with the specified ID as complete.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 400 status code</exception>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PostAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PostAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToPostRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Marks the todo item with the specified ID as complete.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/ItemsItemRequestBuilder.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/ItemsItemRequestBuilder.cs
new file mode 100644
index 0000000000..7a7d75d5df
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/ItemsItemRequestBuilder.cs
@@ -0,0 +1,142 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Api.Items.Item.Complete;
+using TodoApp.Client.Api.Items.Item.Priority;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ItemsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The complete property</summary>
+        public global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder Complete
+        {
+            get => new global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The priority property</summary>
+        public global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder Priority
+        {
+            get => new global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Deletes the todo item with the specified ID.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Gets the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoItemModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoItemModel?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoItemModel> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoItemModel>(requestInfo, global::TodoApp.Client.Models.TodoItemModel.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Deletes the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Gets the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/Priority/PriorityRequestBuilder.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/Priority/PriorityRequestBuilder.cs
new file mode 100644
index 0000000000..52e95a1cb8
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/Item/Priority/PriorityRequestBuilder.cs
@@ -0,0 +1,95 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Item.Priority
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}\priority
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class PriorityRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PriorityRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/priority", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PriorityRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/priority", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </summary>
+        /// <param name="body">Represents the model for updating the priority of a Todo item.</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 400 status code</exception>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PatchAsync(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PatchAsync(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPatchRequestInformation(body, requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents the model for updating the priority of a Todo item.</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPatchRequestInformation(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPatchRequestInformation(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PATCH, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/ItemsRequestBuilder.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/ItemsRequestBuilder.cs
new file mode 100644
index 0000000000..489335512c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Api/Items/ItemsRequestBuilder.cs
@@ -0,0 +1,156 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Api.Items.Find;
+using TodoApp.Client.Api.Items.GetAfter;
+using TodoApp.Client.Api.Items.Item;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ItemsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The find property</summary>
+        public global::TodoApp.Client.Api.Items.Find.FindRequestBuilder Find
+        {
+            get => new global::TodoApp.Client.Api.Items.Find.FindRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The getAfter property</summary>
+        public global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder GetAfter
+        {
+            get => new global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>Gets an item from the TodoApp.Client.api.items.item collection</summary>
+        /// <param name="position">The Todo item&apos;s ID.</param>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/></returns>
+        public global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder this[Guid position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.ItemsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.ItemsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Gets all of the current user&apos;s todo items.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoListViewModel>(requestInfo, global::TodoApp.Client.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.CreatedTodoItemModel"/></returns>
+        /// <param name="body">Represents the model for creating a new Todo item.</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 400 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.CreatedTodoItemModel?> PostAsync(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.CreatedTodoItemModel> PostAsync(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.CreatedTodoItemModel>(requestInfo, global::TodoApp.Client.Models.CreatedTodoItemModel.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Gets all of the current user&apos;s todo items.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents the model for creating a new Todo item.</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.ItemsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.ItemsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.ItemsRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/CreateTodoItemModel.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/CreateTodoItemModel.cs
new file mode 100644
index 0000000000..997121bab3
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/CreateTodoItemModel.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents the model for creating a new Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CreateTodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the text of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Text { get; set; }
+#nullable restore
+#else
+        public string Text { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.CreateTodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.CreateTodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.CreateTodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "text", n => { Text = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("text", Text);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/CreatedTodoItemModel.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/CreatedTodoItemModel.cs
new file mode 100644
index 0000000000..e3ebeb104f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/CreatedTodoItemModel.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents the model for a created Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CreatedTodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the ID of the created Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Id { get; set; }
+#nullable restore
+#else
+        public string Id { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.CreatedTodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.CreatedTodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.CreatedTodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "id", n => { Id = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/ProblemDetails.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/ProblemDetails.cs
new file mode 100644
index 0000000000..49aa45adb4
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/ProblemDetails.cs
@@ -0,0 +1,92 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class ProblemDetails : ApiException, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The detail property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Detail { get; set; }
+#nullable restore
+#else
+        public string Detail { get; set; }
+#endif
+        /// <summary>The instance property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Instance { get; set; }
+#nullable restore
+#else
+        public string Instance { get; set; }
+#endif
+        /// <summary>The primary error message.</summary>
+        public override string Message { get => base.Message; }
+        /// <summary>The status property</summary>
+        public int? Status { get; set; }
+        /// <summary>The title property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Title { get; set; }
+#nullable restore
+#else
+        public string Title { get; set; }
+#endif
+        /// <summary>The type property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Type { get; set; }
+#nullable restore
+#else
+        public string Type { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.ProblemDetails"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.ProblemDetails CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.ProblemDetails();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "detail", n => { Detail = n.GetStringValue(); } },
+                { "instance", n => { Instance = n.GetStringValue(); } },
+                { "status", n => { Status = n.GetIntValue(); } },
+                { "title", n => { Title = n.GetStringValue(); } },
+                { "type", n => { Type = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("detail", Detail);
+            writer.WriteStringValue("instance", Instance);
+            writer.WriteIntValue("status", Status);
+            writer.WriteStringValue("title", Title);
+            writer.WriteStringValue("type", Type);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoItemModel.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoItemModel.cs
new file mode 100644
index 0000000000..10a9a52b98
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoItemModel.cs
@@ -0,0 +1,82 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents a Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the date and time the item was completed.</summary>
+        public DateTimeOffset? CompletedAt { get; set; }
+        /// <summary>Gets or sets the date and time the item was created.</summary>
+        public DateTimeOffset? CreatedAt { get; set; }
+        /// <summary>Gets or sets the ID of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Id { get; set; }
+#nullable restore
+#else
+        public string Id { get; set; }
+#endif
+        /// <summary>Gets or sets the date and time the Todo item was last updated.</summary>
+        public DateTimeOffset? LastUpdated { get; set; }
+        /// <summary>Gets or sets the optional priority of the Todo item.</summary>
+        public global::TodoApp.Client.Models.TodoPriority? Priority { get; set; }
+        /// <summary>Gets or sets the text of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Text { get; set; }
+#nullable restore
+#else
+        public string Text { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.TodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.TodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "completedAt", n => { CompletedAt = n.GetDateTimeOffsetValue(); } },
+                { "createdAt", n => { CreatedAt = n.GetDateTimeOffsetValue(); } },
+                { "id", n => { Id = n.GetStringValue(); } },
+                { "lastUpdated", n => { LastUpdated = n.GetDateTimeOffsetValue(); } },
+                { "priority", n => { Priority = n.GetEnumValue<global::TodoApp.Client.Models.TodoPriority>(); } },
+                { "text", n => { Text = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDateTimeOffsetValue("completedAt", CompletedAt);
+            writer.WriteDateTimeOffsetValue("createdAt", CreatedAt);
+            writer.WriteStringValue("id", Id);
+            writer.WriteDateTimeOffsetValue("lastUpdated", LastUpdated);
+            writer.WriteEnumValue<global::TodoApp.Client.Models.TodoPriority>("priority", Priority);
+            writer.WriteStringValue("text", Text);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoListViewModel.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoListViewModel.cs
new file mode 100644
index 0000000000..d7fb2e91ac
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoListViewModel.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents a collection of Todo items.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoListViewModel : IParsable
+    {
+        /// <summary>Gets or sets the Todo item(s).</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public List<global::TodoApp.Client.Models.TodoItemModel>? Items { get; set; }
+#nullable restore
+#else
+        public List<global::TodoApp.Client.Models.TodoItemModel> Items { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.TodoListViewModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.TodoListViewModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "items", n => { Items = n.GetCollectionOfObjectValues<global::TodoApp.Client.Models.TodoItemModel>(global::TodoApp.Client.Models.TodoItemModel.CreateFromDiscriminatorValue)?.AsList(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteCollectionOfObjectValues<global::TodoApp.Client.Models.TodoItemModel>("items", Items);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoPriority.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoPriority.cs
new file mode 100644
index 0000000000..5200deb280
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/TodoPriority.cs
@@ -0,0 +1,23 @@
+// <auto-generated/>
+using System.Runtime.Serialization;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>The priority levels for a Todo item.</summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public enum TodoPriority
+    {
+        [EnumMember(Value = "Normal")]
+        #pragma warning disable CS1591
+        Normal,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "Low")]
+        #pragma warning disable CS1591
+        Low,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "High")]
+        #pragma warning disable CS1591
+        High,
+        #pragma warning restore CS1591
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/UpdateTodoItemPriorityModel.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/UpdateTodoItemPriorityModel.cs
new file mode 100644
index 0000000000..f2a9c6e583
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/Models/UpdateTodoItemPriorityModel.cs
@@ -0,0 +1,50 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents the model for updating the priority of a Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class UpdateTodoItemPriorityModel : IParsable
+    {
+        /// <summary>Gets or sets the new priority of the Todo item.</summary>
+        public global::TodoApp.Client.Models.TodoPriority? Priority { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.UpdateTodoItemPriorityModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.UpdateTodoItemPriorityModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.UpdateTodoItemPriorityModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "priority", n => { Priority = n.GetEnumValue<global::TodoApp.Client.Models.TodoPriority>(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteEnumValue<global::TodoApp.Client.Models.TodoPriority>("priority", Priority);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/TodoApiClient.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/TodoApiClient.cs
new file mode 100644
index 0000000000..0d5631bb7d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/TodoApiClient.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+using TodoApp.Client.Api;
+namespace TodoApp.Client
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoApiClient : BaseRequestBuilder
+    {
+        /// <summary>The api property</summary>
+        public global::TodoApp.Client.Api.ApiRequestBuilder Api
+        {
+            get => new global::TodoApp.Client.Api.ApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.TodoApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TodoApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/kiota-lock.json b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/kiota-lock.json
new file mode 100644
index 0000000000..497c46d4b3
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/TodoClient/kiota-lock.json
@@ -0,0 +1,31 @@
+{
+  "descriptionHash": "6220470D2DBDA8D33A3A26AE0D99FD08E8CA025558CE7AF3EFA771BEE7F540049DFB9E14E28367BD30CC488F5A918670E40CF226C0C825CC163EDBFFA1CCE766",
+  "descriptionLocation": "../snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt",
+  "lockFileVersion": "1.0.0",
+  "kiotaVersion": "1.29.0",
+  "clientClassName": "TodoApiClient",
+  "typeAccessModifier": "Public",
+  "clientNamespaceName": "TodoApp.Client",
+  "language": "CSharp",
+  "usesBackingStore": false,
+  "excludeBackwardCompatible": true,
+  "includeAdditionalData": false,
+  "disableSSLValidation": false,
+  "serializers": [
+    "Microsoft.Kiota.Serialization.Json.JsonSerializationWriterFactory",
+    "Microsoft.Kiota.Serialization.Text.TextSerializationWriterFactory",
+    "Microsoft.Kiota.Serialization.Form.FormSerializationWriterFactory",
+    "Microsoft.Kiota.Serialization.Multipart.MultipartSerializationWriterFactory"
+  ],
+  "deserializers": [
+    "Microsoft.Kiota.Serialization.Json.JsonParseNodeFactory",
+    "Microsoft.Kiota.Serialization.Text.TextParseNodeFactory",
+    "Microsoft.Kiota.Serialization.Form.FormParseNodeFactory"
+  ],
+  "structuredMimeTypes": [
+    "application/json"
+  ],
+  "includePatterns": [],
+  "excludePatterns": [],
+  "disabledValidationRules": []
+}
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/VerifyTests.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/VerifyTests.cs
index 650ea85e31..606400e63c 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/VerifyTests.cs
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/VerifyTests.cs
@@ -58,6 +58,7 @@ await Verify(swagger)
     [InlineData(typeof(MinimalApp.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(MinimalAppWithNullableEnums.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(MvcWithNullable.Program), "/swagger/v1/swagger.json")]
+    [InlineData(typeof(TodoApp.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(TopLevelSwaggerDoc.Program), "/swagger/v1.json")]
     [InlineData(typeof(WebApi.Program), "/swagger/v1/swagger.json")]
     [InlineData(typeof(WebApi.Aot.Program), "/swagger/v1/swagger.json")]
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/generate-todo-client.ps1 b/test/Swashbuckle.AspNetCore.IntegrationTests/generate-todo-client.ps1
new file mode 100644
index 0000000000..2e5ff31862
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/generate-todo-client.ps1
@@ -0,0 +1,28 @@
+#! /usr/bin/env pwsh
+
+param(
+    [Parameter(Mandatory = $false)][string] $OpenApiUrl = "./snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt",
+    [Parameter(Mandatory = $false)][switch] $Regenerate
+)
+
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+$env:KIOTA_TUTORIAL_ENABLED = "false"
+
+$OutputPath = "./TodoClient"
+
+dotnet kiota generate `
+    --additional-data false `
+    --class-name TodoApiClient `
+    --clean-output `
+    --exclude-backward-compatible `
+    --language csharp `
+    --namespace-name TodoApp.Client `
+    --openapi $OpenApiUrl `
+    --output $OutputPath `
+    --structured-mime-types "application/json"
+
+if ($LASTEXITCODE -ne 0) {
+    throw "Kiota generation failed with exit code ${LASTEXITCODE}"
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.2.0.json b/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.2.0.json
new file mode 100644
index 0000000000..ebe10ed32d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.2.0.json
@@ -0,0 +1,1607 @@
+{
+  "title": "A JSON Schema for Swagger 2.0 API.",
+  "id": "http://swagger.io/v2/schema.json#",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "required": [
+    "swagger",
+    "info",
+    "paths"
+  ],
+  "additionalProperties": false,
+  "patternProperties": {
+    "^x-": {
+      "$ref": "#/definitions/vendorExtension"
+    }
+  },
+  "properties": {
+    "swagger": {
+      "type": "string",
+      "enum": [
+        "2.0"
+      ],
+      "description": "The Swagger version of this document."
+    },
+    "info": {
+      "$ref": "#/definitions/info"
+    },
+    "host": {
+      "type": "string",
+      "pattern": "^[^{}/ :\\\\]+(?::\\d+)?$",
+      "description": "The host (name or ip) of the API. Example: 'swagger.io'"
+    },
+    "basePath": {
+      "type": "string",
+      "pattern": "^/",
+      "description": "The base path to the API. Example: '/api'."
+    },
+    "schemes": {
+      "$ref": "#/definitions/schemesList"
+    },
+    "consumes": {
+      "description": "A list of MIME types accepted by the API.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/mediaTypeList"
+        }
+      ]
+    },
+    "produces": {
+      "description": "A list of MIME types the API can produce.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/mediaTypeList"
+        }
+      ]
+    },
+    "paths": {
+      "$ref": "#/definitions/paths"
+    },
+    "definitions": {
+      "$ref": "#/definitions/definitions"
+    },
+    "parameters": {
+      "$ref": "#/definitions/parameterDefinitions"
+    },
+    "responses": {
+      "$ref": "#/definitions/responseDefinitions"
+    },
+    "security": {
+      "$ref": "#/definitions/security"
+    },
+    "securityDefinitions": {
+      "$ref": "#/definitions/securityDefinitions"
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/tag"
+      },
+      "uniqueItems": true
+    },
+    "externalDocs": {
+      "$ref": "#/definitions/externalDocs"
+    }
+  },
+  "definitions": {
+    "info": {
+      "type": "object",
+      "description": "General information about the API.",
+      "required": [
+        "version",
+        "title"
+      ],
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "title": {
+          "type": "string",
+          "description": "A unique and precise title of the API."
+        },
+        "version": {
+          "type": "string",
+          "description": "A semantic version number of the API."
+        },
+        "description": {
+          "type": "string",
+          "description": "A longer description of the API. Should be different from the title.  GitHub Flavored Markdown is allowed."
+        },
+        "termsOfService": {
+          "type": "string",
+          "description": "The terms of service for the API."
+        },
+        "contact": {
+          "$ref": "#/definitions/contact"
+        },
+        "license": {
+          "$ref": "#/definitions/license"
+        }
+      }
+    },
+    "contact": {
+      "type": "object",
+      "description": "Contact information for the owners of the API.",
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The identifying name of the contact person/organization."
+        },
+        "url": {
+          "type": "string",
+          "description": "The URL pointing to the contact information.",
+          "format": "uri"
+        },
+        "email": {
+          "type": "string",
+          "description": "The email address of the contact person/organization.",
+          "format": "email"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "license": {
+      "type": "object",
+      "required": [
+        "name"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The name of the license type. It's encouraged to use an OSI compatible license."
+        },
+        "url": {
+          "type": "string",
+          "description": "The URL pointing to the license.",
+          "format": "uri"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "paths": {
+      "type": "object",
+      "description": "Relative paths to the individual endpoints. They must be relative to the 'basePath'.",
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        },
+        "^/": {
+          "$ref": "#/definitions/pathItem"
+        }
+      },
+      "additionalProperties": false
+    },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/schema"
+      },
+      "description": "One or more JSON objects describing the schemas being consumed and produced by the API."
+    },
+    "parameterDefinitions": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/parameter"
+      },
+      "description": "One or more JSON representations for parameters"
+    },
+    "responseDefinitions": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/response"
+      },
+      "description": "One or more JSON representations for responses"
+    },
+    "externalDocs": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "information about external documentation",
+      "required": [
+        "url"
+      ],
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "examples": {
+      "type": "object",
+      "additionalProperties": true
+    },
+    "mimeType": {
+      "type": "string",
+      "description": "The MIME type of the HTTP message."
+    },
+    "operation": {
+      "type": "object",
+      "required": [
+        "responses"
+      ],
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "uniqueItems": true
+        },
+        "summary": {
+          "type": "string",
+          "description": "A brief summary of the operation."
+        },
+        "description": {
+          "type": "string",
+          "description": "A longer description of the operation, GitHub Flavored Markdown is allowed."
+        },
+        "externalDocs": {
+          "$ref": "#/definitions/externalDocs"
+        },
+        "operationId": {
+          "type": "string",
+          "description": "A unique identifier of the operation."
+        },
+        "produces": {
+          "description": "A list of MIME types the API can produce.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/mediaTypeList"
+            }
+          ]
+        },
+        "consumes": {
+          "description": "A list of MIME types the API can consume.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/mediaTypeList"
+            }
+          ]
+        },
+        "parameters": {
+          "$ref": "#/definitions/parametersList"
+        },
+        "responses": {
+          "$ref": "#/definitions/responses"
+        },
+        "schemes": {
+          "$ref": "#/definitions/schemesList"
+        },
+        "deprecated": {
+          "type": "boolean",
+          "default": false
+        },
+        "security": {
+          "$ref": "#/definitions/security"
+        }
+      }
+    },
+    "pathItem": {
+      "type": "object",
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "$ref": {
+          "type": "string"
+        },
+        "get": {
+          "$ref": "#/definitions/operation"
+        },
+        "put": {
+          "$ref": "#/definitions/operation"
+        },
+        "post": {
+          "$ref": "#/definitions/operation"
+        },
+        "delete": {
+          "$ref": "#/definitions/operation"
+        },
+        "options": {
+          "$ref": "#/definitions/operation"
+        },
+        "head": {
+          "$ref": "#/definitions/operation"
+        },
+        "patch": {
+          "$ref": "#/definitions/operation"
+        },
+        "parameters": {
+          "$ref": "#/definitions/parametersList"
+        }
+      }
+    },
+    "responses": {
+      "type": "object",
+      "description": "Response objects names can either be any valid HTTP status code or 'default'.",
+      "minProperties": 1,
+      "additionalProperties": false,
+      "patternProperties": {
+        "^([0-9]{3})$|^(default)$": {
+          "$ref": "#/definitions/responseValue"
+        },
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "not": {
+        "type": "object",
+        "additionalProperties": false,
+        "patternProperties": {
+          "^x-": {
+            "$ref": "#/definitions/vendorExtension"
+          }
+        }
+      }
+    },
+    "responseValue": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/response"
+        },
+        {
+          "$ref": "#/definitions/jsonReference"
+        }
+      ]
+    },
+    "response": {
+      "type": "object",
+      "required": [
+        "description"
+      ],
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "schema": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/schema"
+            },
+            {
+              "$ref": "#/definitions/fileSchema"
+            }
+          ]
+        },
+        "headers": {
+          "$ref": "#/definitions/headers"
+        },
+        "examples": {
+          "$ref": "#/definitions/examples"
+        }
+      },
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "headers": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/header"
+      }
+    },
+    "header": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "string",
+            "number",
+            "integer",
+            "boolean",
+            "array"
+          ]
+        },
+        "format": {
+          "type": "string"
+        },
+        "items": {
+          "$ref": "#/definitions/primitivesItems"
+        },
+        "collectionFormat": {
+          "$ref": "#/definitions/collectionFormat"
+        },
+        "default": {
+          "$ref": "#/definitions/default"
+        },
+        "maximum": {
+          "$ref": "#/definitions/maximum"
+        },
+        "exclusiveMaximum": {
+          "$ref": "#/definitions/exclusiveMaximum"
+        },
+        "minimum": {
+          "$ref": "#/definitions/minimum"
+        },
+        "exclusiveMinimum": {
+          "$ref": "#/definitions/exclusiveMinimum"
+        },
+        "maxLength": {
+          "$ref": "#/definitions/maxLength"
+        },
+        "minLength": {
+          "$ref": "#/definitions/minLength"
+        },
+        "pattern": {
+          "$ref": "#/definitions/pattern"
+        },
+        "maxItems": {
+          "$ref": "#/definitions/maxItems"
+        },
+        "minItems": {
+          "$ref": "#/definitions/minItems"
+        },
+        "uniqueItems": {
+          "$ref": "#/definitions/uniqueItems"
+        },
+        "enum": {
+          "$ref": "#/definitions/enum"
+        },
+        "multipleOf": {
+          "$ref": "#/definitions/multipleOf"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "vendorExtension": {
+      "description": "Any property starting with x- is valid.",
+      "additionalProperties": true,
+      "additionalItems": true
+    },
+    "bodyParameter": {
+      "type": "object",
+      "required": [
+        "name",
+        "in",
+        "schema"
+      ],
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "description": {
+          "type": "string",
+          "description": "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the parameter."
+        },
+        "in": {
+          "type": "string",
+          "description": "Determines the location of the parameter.",
+          "enum": [
+            "body"
+          ]
+        },
+        "required": {
+          "type": "boolean",
+          "description": "Determines whether or not this parameter is required or optional.",
+          "default": false
+        },
+        "schema": {
+          "$ref": "#/definitions/schema"
+        }
+      },
+      "additionalProperties": false
+    },
+    "headerParameterSubSchema": {
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "required": {
+          "type": "boolean",
+          "description": "Determines whether or not this parameter is required or optional.",
+          "default": false
+        },
+        "in": {
+          "type": "string",
+          "description": "Determines the location of the parameter.",
+          "enum": [
+            "header"
+          ]
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the parameter."
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "string",
+            "number",
+            "boolean",
+            "integer",
+            "array"
+          ]
+        },
+        "format": {
+          "type": "string"
+        },
+        "items": {
+          "$ref": "#/definitions/primitivesItems"
+        },
+        "collectionFormat": {
+          "$ref": "#/definitions/collectionFormat"
+        },
+        "default": {
+          "$ref": "#/definitions/default"
+        },
+        "maximum": {
+          "$ref": "#/definitions/maximum"
+        },
+        "exclusiveMaximum": {
+          "$ref": "#/definitions/exclusiveMaximum"
+        },
+        "minimum": {
+          "$ref": "#/definitions/minimum"
+        },
+        "exclusiveMinimum": {
+          "$ref": "#/definitions/exclusiveMinimum"
+        },
+        "maxLength": {
+          "$ref": "#/definitions/maxLength"
+        },
+        "minLength": {
+          "$ref": "#/definitions/minLength"
+        },
+        "pattern": {
+          "$ref": "#/definitions/pattern"
+        },
+        "maxItems": {
+          "$ref": "#/definitions/maxItems"
+        },
+        "minItems": {
+          "$ref": "#/definitions/minItems"
+        },
+        "uniqueItems": {
+          "$ref": "#/definitions/uniqueItems"
+        },
+        "enum": {
+          "$ref": "#/definitions/enum"
+        },
+        "multipleOf": {
+          "$ref": "#/definitions/multipleOf"
+        }
+      }
+    },
+    "queryParameterSubSchema": {
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "required": {
+          "type": "boolean",
+          "description": "Determines whether or not this parameter is required or optional.",
+          "default": false
+        },
+        "in": {
+          "type": "string",
+          "description": "Determines the location of the parameter.",
+          "enum": [
+            "query"
+          ]
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the parameter."
+        },
+        "allowEmptyValue": {
+          "type": "boolean",
+          "default": false,
+          "description": "allows sending a parameter by name only or with an empty value."
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "string",
+            "number",
+            "boolean",
+            "integer",
+            "array"
+          ]
+        },
+        "format": {
+          "type": "string"
+        },
+        "items": {
+          "$ref": "#/definitions/primitivesItems"
+        },
+        "collectionFormat": {
+          "$ref": "#/definitions/collectionFormatWithMulti"
+        },
+        "default": {
+          "$ref": "#/definitions/default"
+        },
+        "maximum": {
+          "$ref": "#/definitions/maximum"
+        },
+        "exclusiveMaximum": {
+          "$ref": "#/definitions/exclusiveMaximum"
+        },
+        "minimum": {
+          "$ref": "#/definitions/minimum"
+        },
+        "exclusiveMinimum": {
+          "$ref": "#/definitions/exclusiveMinimum"
+        },
+        "maxLength": {
+          "$ref": "#/definitions/maxLength"
+        },
+        "minLength": {
+          "$ref": "#/definitions/minLength"
+        },
+        "pattern": {
+          "$ref": "#/definitions/pattern"
+        },
+        "maxItems": {
+          "$ref": "#/definitions/maxItems"
+        },
+        "minItems": {
+          "$ref": "#/definitions/minItems"
+        },
+        "uniqueItems": {
+          "$ref": "#/definitions/uniqueItems"
+        },
+        "enum": {
+          "$ref": "#/definitions/enum"
+        },
+        "multipleOf": {
+          "$ref": "#/definitions/multipleOf"
+        }
+      }
+    },
+    "formDataParameterSubSchema": {
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "required": {
+          "type": "boolean",
+          "description": "Determines whether or not this parameter is required or optional.",
+          "default": false
+        },
+        "in": {
+          "type": "string",
+          "description": "Determines the location of the parameter.",
+          "enum": [
+            "formData"
+          ]
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the parameter."
+        },
+        "allowEmptyValue": {
+          "type": "boolean",
+          "default": false,
+          "description": "allows sending a parameter by name only or with an empty value."
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "string",
+            "number",
+            "boolean",
+            "integer",
+            "array",
+            "file"
+          ]
+        },
+        "format": {
+          "type": "string"
+        },
+        "items": {
+          "$ref": "#/definitions/primitivesItems"
+        },
+        "collectionFormat": {
+          "$ref": "#/definitions/collectionFormatWithMulti"
+        },
+        "default": {
+          "$ref": "#/definitions/default"
+        },
+        "maximum": {
+          "$ref": "#/definitions/maximum"
+        },
+        "exclusiveMaximum": {
+          "$ref": "#/definitions/exclusiveMaximum"
+        },
+        "minimum": {
+          "$ref": "#/definitions/minimum"
+        },
+        "exclusiveMinimum": {
+          "$ref": "#/definitions/exclusiveMinimum"
+        },
+        "maxLength": {
+          "$ref": "#/definitions/maxLength"
+        },
+        "minLength": {
+          "$ref": "#/definitions/minLength"
+        },
+        "pattern": {
+          "$ref": "#/definitions/pattern"
+        },
+        "maxItems": {
+          "$ref": "#/definitions/maxItems"
+        },
+        "minItems": {
+          "$ref": "#/definitions/minItems"
+        },
+        "uniqueItems": {
+          "$ref": "#/definitions/uniqueItems"
+        },
+        "enum": {
+          "$ref": "#/definitions/enum"
+        },
+        "multipleOf": {
+          "$ref": "#/definitions/multipleOf"
+        }
+      }
+    },
+    "pathParameterSubSchema": {
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "required": [
+        "required"
+      ],
+      "properties": {
+        "required": {
+          "type": "boolean",
+          "enum": [
+            true
+          ],
+          "description": "Determines whether or not this parameter is required or optional."
+        },
+        "in": {
+          "type": "string",
+          "description": "Determines the location of the parameter.",
+          "enum": [
+            "path"
+          ]
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the parameter. This could contain examples of use.  GitHub Flavored Markdown is allowed."
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the parameter."
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "string",
+            "number",
+            "boolean",
+            "integer",
+            "array"
+          ]
+        },
+        "format": {
+          "type": "string"
+        },
+        "items": {
+          "$ref": "#/definitions/primitivesItems"
+        },
+        "collectionFormat": {
+          "$ref": "#/definitions/collectionFormat"
+        },
+        "default": {
+          "$ref": "#/definitions/default"
+        },
+        "maximum": {
+          "$ref": "#/definitions/maximum"
+        },
+        "exclusiveMaximum": {
+          "$ref": "#/definitions/exclusiveMaximum"
+        },
+        "minimum": {
+          "$ref": "#/definitions/minimum"
+        },
+        "exclusiveMinimum": {
+          "$ref": "#/definitions/exclusiveMinimum"
+        },
+        "maxLength": {
+          "$ref": "#/definitions/maxLength"
+        },
+        "minLength": {
+          "$ref": "#/definitions/minLength"
+        },
+        "pattern": {
+          "$ref": "#/definitions/pattern"
+        },
+        "maxItems": {
+          "$ref": "#/definitions/maxItems"
+        },
+        "minItems": {
+          "$ref": "#/definitions/minItems"
+        },
+        "uniqueItems": {
+          "$ref": "#/definitions/uniqueItems"
+        },
+        "enum": {
+          "$ref": "#/definitions/enum"
+        },
+        "multipleOf": {
+          "$ref": "#/definitions/multipleOf"
+        }
+      }
+    },
+    "nonBodyParameter": {
+      "type": "object",
+      "required": [
+        "name",
+        "in",
+        "type"
+      ],
+      "oneOf": [
+        {
+          "$ref": "#/definitions/headerParameterSubSchema"
+        },
+        {
+          "$ref": "#/definitions/formDataParameterSubSchema"
+        },
+        {
+          "$ref": "#/definitions/queryParameterSubSchema"
+        },
+        {
+          "$ref": "#/definitions/pathParameterSubSchema"
+        }
+      ]
+    },
+    "parameter": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/bodyParameter"
+        },
+        {
+          "$ref": "#/definitions/nonBodyParameter"
+        }
+      ]
+    },
+    "schema": {
+      "type": "object",
+      "description": "A deterministic version of a JSON Schema object.",
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "$ref": {
+          "type": "string"
+        },
+        "format": {
+          "type": "string"
+        },
+        "title": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/title"
+        },
+        "description": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/description"
+        },
+        "default": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/default"
+        },
+        "multipleOf": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf"
+        },
+        "maximum": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/maximum"
+        },
+        "exclusiveMaximum": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum"
+        },
+        "minimum": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/minimum"
+        },
+        "exclusiveMinimum": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum"
+        },
+        "maxLength": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
+        },
+        "minLength": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
+        },
+        "pattern": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/pattern"
+        },
+        "maxItems": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
+        },
+        "minItems": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
+        },
+        "uniqueItems": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems"
+        },
+        "maxProperties": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
+        },
+        "minProperties": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
+        },
+        "required": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray"
+        },
+        "enum": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/enum"
+        },
+        "additionalProperties": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/schema"
+            },
+            {
+              "type": "boolean"
+            }
+          ],
+          "default": {}
+        },
+        "type": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/type"
+        },
+        "items": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/schema"
+            },
+            {
+              "type": "array",
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/schema"
+              }
+            }
+          ],
+          "default": {}
+        },
+        "allOf": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/definitions/schema"
+          }
+        },
+        "properties": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/schema"
+          },
+          "default": {}
+        },
+        "discriminator": {
+          "type": "string"
+        },
+        "readOnly": {
+          "type": "boolean",
+          "default": false
+        },
+        "xml": {
+          "$ref": "#/definitions/xml"
+        },
+        "externalDocs": {
+          "$ref": "#/definitions/externalDocs"
+        },
+        "example": {}
+      },
+      "additionalProperties": false
+    },
+    "fileSchema": {
+      "type": "object",
+      "description": "A deterministic version of a JSON Schema object.",
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "required": [
+        "type"
+      ],
+      "properties": {
+        "format": {
+          "type": "string"
+        },
+        "title": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/title"
+        },
+        "description": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/description"
+        },
+        "default": {
+          "$ref": "http://json-schema.org/draft-04/schema#/properties/default"
+        },
+        "required": {
+          "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray"
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "file"
+          ]
+        },
+        "readOnly": {
+          "type": "boolean",
+          "default": false
+        },
+        "externalDocs": {
+          "$ref": "#/definitions/externalDocs"
+        },
+        "example": {}
+      },
+      "additionalProperties": false
+    },
+    "primitivesItems": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "string",
+            "number",
+            "integer",
+            "boolean",
+            "array"
+          ]
+        },
+        "format": {
+          "type": "string"
+        },
+        "items": {
+          "$ref": "#/definitions/primitivesItems"
+        },
+        "collectionFormat": {
+          "$ref": "#/definitions/collectionFormat"
+        },
+        "default": {
+          "$ref": "#/definitions/default"
+        },
+        "maximum": {
+          "$ref": "#/definitions/maximum"
+        },
+        "exclusiveMaximum": {
+          "$ref": "#/definitions/exclusiveMaximum"
+        },
+        "minimum": {
+          "$ref": "#/definitions/minimum"
+        },
+        "exclusiveMinimum": {
+          "$ref": "#/definitions/exclusiveMinimum"
+        },
+        "maxLength": {
+          "$ref": "#/definitions/maxLength"
+        },
+        "minLength": {
+          "$ref": "#/definitions/minLength"
+        },
+        "pattern": {
+          "$ref": "#/definitions/pattern"
+        },
+        "maxItems": {
+          "$ref": "#/definitions/maxItems"
+        },
+        "minItems": {
+          "$ref": "#/definitions/minItems"
+        },
+        "uniqueItems": {
+          "$ref": "#/definitions/uniqueItems"
+        },
+        "enum": {
+          "$ref": "#/definitions/enum"
+        },
+        "multipleOf": {
+          "$ref": "#/definitions/multipleOf"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "security": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/securityRequirement"
+      },
+      "uniqueItems": true
+    },
+    "securityRequirement": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "uniqueItems": true
+      }
+    },
+    "xml": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "namespace": {
+          "type": "string"
+        },
+        "prefix": {
+          "type": "string"
+        },
+        "attribute": {
+          "type": "boolean",
+          "default": false
+        },
+        "wrapped": {
+          "type": "boolean",
+          "default": false
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "tag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "name"
+      ],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "externalDocs": {
+          "$ref": "#/definitions/externalDocs"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "securityDefinitions": {
+      "type": "object",
+      "additionalProperties": {
+        "oneOf": [
+          {
+            "$ref": "#/definitions/basicAuthenticationSecurity"
+          },
+          {
+            "$ref": "#/definitions/apiKeySecurity"
+          },
+          {
+            "$ref": "#/definitions/oauth2ImplicitSecurity"
+          },
+          {
+            "$ref": "#/definitions/oauth2PasswordSecurity"
+          },
+          {
+            "$ref": "#/definitions/oauth2ApplicationSecurity"
+          },
+          {
+            "$ref": "#/definitions/oauth2AccessCodeSecurity"
+          }
+        ]
+      }
+    },
+    "basicAuthenticationSecurity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "basic"
+          ]
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "apiKeySecurity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type",
+        "name",
+        "in"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "apiKey"
+          ]
+        },
+        "name": {
+          "type": "string"
+        },
+        "in": {
+          "type": "string",
+          "enum": [
+            "header",
+            "query"
+          ]
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "oauth2ImplicitSecurity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type",
+        "flow",
+        "authorizationUrl"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "oauth2"
+          ]
+        },
+        "flow": {
+          "type": "string",
+          "enum": [
+            "implicit"
+          ]
+        },
+        "scopes": {
+          "$ref": "#/definitions/oauth2Scopes"
+        },
+        "authorizationUrl": {
+          "type": "string",
+          "format": "uri"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "oauth2PasswordSecurity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type",
+        "flow",
+        "tokenUrl"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "oauth2"
+          ]
+        },
+        "flow": {
+          "type": "string",
+          "enum": [
+            "password"
+          ]
+        },
+        "scopes": {
+          "$ref": "#/definitions/oauth2Scopes"
+        },
+        "tokenUrl": {
+          "type": "string",
+          "format": "uri"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "oauth2ApplicationSecurity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type",
+        "flow",
+        "tokenUrl"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "oauth2"
+          ]
+        },
+        "flow": {
+          "type": "string",
+          "enum": [
+            "application"
+          ]
+        },
+        "scopes": {
+          "$ref": "#/definitions/oauth2Scopes"
+        },
+        "tokenUrl": {
+          "type": "string",
+          "format": "uri"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "oauth2AccessCodeSecurity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "type",
+        "flow",
+        "authorizationUrl",
+        "tokenUrl"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "oauth2"
+          ]
+        },
+        "flow": {
+          "type": "string",
+          "enum": [
+            "accessCode"
+          ]
+        },
+        "scopes": {
+          "$ref": "#/definitions/oauth2Scopes"
+        },
+        "authorizationUrl": {
+          "type": "string",
+          "format": "uri"
+        },
+        "tokenUrl": {
+          "type": "string",
+          "format": "uri"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "oauth2Scopes": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "mediaTypeList": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/mimeType"
+      },
+      "uniqueItems": true
+    },
+    "parametersList": {
+      "type": "array",
+      "description": "The parameters needed to send a valid API call.",
+      "additionalItems": false,
+      "items": {
+        "oneOf": [
+          {
+            "$ref": "#/definitions/parameter"
+          },
+          {
+            "$ref": "#/definitions/jsonReference"
+          }
+        ]
+      },
+      "uniqueItems": true
+    },
+    "schemesList": {
+      "type": "array",
+      "description": "The transfer protocol of the API.",
+      "items": {
+        "type": "string",
+        "enum": [
+          "http",
+          "https",
+          "ws",
+          "wss"
+        ]
+      },
+      "uniqueItems": true
+    },
+    "collectionFormat": {
+      "type": "string",
+      "enum": [
+        "csv",
+        "ssv",
+        "tsv",
+        "pipes"
+      ],
+      "default": "csv"
+    },
+    "collectionFormatWithMulti": {
+      "type": "string",
+      "enum": [
+        "csv",
+        "ssv",
+        "tsv",
+        "pipes",
+        "multi"
+      ],
+      "default": "csv"
+    },
+    "title": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/title"
+    },
+    "description": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/description"
+    },
+    "default": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/default"
+    },
+    "multipleOf": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf"
+    },
+    "maximum": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/maximum"
+    },
+    "exclusiveMaximum": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum"
+    },
+    "minimum": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/minimum"
+    },
+    "exclusiveMinimum": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum"
+    },
+    "maxLength": {
+      "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
+    },
+    "minLength": {
+      "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
+    },
+    "pattern": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/pattern"
+    },
+    "maxItems": {
+      "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
+    },
+    "minItems": {
+      "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
+    },
+    "uniqueItems": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems"
+    },
+    "enum": {
+      "$ref": "http://json-schema.org/draft-04/schema#/properties/enum"
+    },
+    "jsonReference": {
+      "type": "object",
+      "required": [
+        "$ref"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "$ref": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.3.0.json b/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.3.0.json
new file mode 100644
index 0000000000..a40570a367
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.3.0.json
@@ -0,0 +1,1651 @@
+{
+  "id": "https://spec.openapis.org/oas/3.0/schema/2024-10-18",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "The description of OpenAPI v3.0.x Documents",
+  "type": "object",
+  "required": [
+    "openapi",
+    "info",
+    "paths"
+  ],
+  "properties": {
+    "openapi": {
+      "type": "string",
+      "pattern": "^3\\.0\\.\\d(-.+)?$"
+    },
+    "info": {
+      "$ref": "#/definitions/Info"
+    },
+    "externalDocs": {
+      "$ref": "#/definitions/ExternalDocumentation"
+    },
+    "servers": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Server"
+      }
+    },
+    "security": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/SecurityRequirement"
+      }
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Tag"
+      },
+      "uniqueItems": true
+    },
+    "paths": {
+      "$ref": "#/definitions/Paths"
+    },
+    "components": {
+      "$ref": "#/definitions/Components"
+    }
+  },
+  "patternProperties": {
+    "^x-": {}
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "Reference": {
+      "type": "object",
+      "required": [
+        "$ref"
+      ],
+      "patternProperties": {
+        "^\\$ref$": {
+          "type": "string",
+          "format": "uri-reference"
+        }
+      }
+    },
+    "Info": {
+      "type": "object",
+      "required": [
+        "title",
+        "version"
+      ],
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "termsOfService": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "contact": {
+          "$ref": "#/definitions/Contact"
+        },
+        "license": {
+          "$ref": "#/definitions/License"
+        },
+        "version": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Contact": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "email": {
+          "type": "string",
+          "format": "email"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "License": {
+      "type": "object",
+      "required": [
+        "name"
+      ],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri-reference"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Server": {
+      "type": "object",
+      "required": [
+        "url"
+      ],
+      "properties": {
+        "url": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "variables": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/ServerVariable"
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "ServerVariable": {
+      "type": "object",
+      "required": [
+        "default"
+      ],
+      "properties": {
+        "enum": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "default": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Components": {
+      "type": "object",
+      "properties": {
+        "schemas": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Schema"
+                },
+                {
+                  "$ref": "#/definitions/Reference"
+                }
+              ]
+            }
+          }
+        },
+        "responses": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/Response"
+                }
+              ]
+            }
+          }
+        },
+        "parameters": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/Parameter"
+                }
+              ]
+            }
+          }
+        },
+        "examples": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/Example"
+                }
+              ]
+            }
+          }
+        },
+        "requestBodies": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/RequestBody"
+                }
+              ]
+            }
+          }
+        },
+        "headers": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/Header"
+                }
+              ]
+            }
+          }
+        },
+        "securitySchemes": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/SecurityScheme"
+                }
+              ]
+            }
+          }
+        },
+        "links": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/Link"
+                }
+              ]
+            }
+          }
+        },
+        "callbacks": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9\\.\\-_]+$": {
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/Reference"
+                },
+                {
+                  "$ref": "#/definitions/Callback"
+                }
+              ]
+            }
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Schema": {
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "multipleOf": {
+          "type": "number",
+          "minimum": 0,
+          "exclusiveMinimum": true
+        },
+        "maximum": {
+          "type": "number"
+        },
+        "exclusiveMaximum": {
+          "type": "boolean",
+          "default": false
+        },
+        "minimum": {
+          "type": "number"
+        },
+        "exclusiveMinimum": {
+          "type": "boolean",
+          "default": false
+        },
+        "maxLength": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "minLength": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0
+        },
+        "pattern": {
+          "type": "string",
+          "format": "regex"
+        },
+        "maxItems": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "minItems": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0
+        },
+        "uniqueItems": {
+          "type": "boolean",
+          "default": false
+        },
+        "maxProperties": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "minProperties": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0
+        },
+        "required": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "minItems": 1,
+          "uniqueItems": true
+        },
+        "enum": {
+          "type": "array",
+          "items": {},
+          "minItems": 1,
+          "uniqueItems": false
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "array",
+            "boolean",
+            "integer",
+            "number",
+            "object",
+            "string"
+          ]
+        },
+        "not": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Schema"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        },
+        "allOf": {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Schema"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "oneOf": {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Schema"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "anyOf": {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Schema"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "items": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Schema"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        },
+        "properties": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Schema"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "additionalProperties": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Schema"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            },
+            {
+              "type": "boolean"
+            }
+          ],
+          "default": true
+        },
+        "description": {
+          "type": "string"
+        },
+        "format": {
+          "type": "string"
+        },
+        "default": {},
+        "nullable": {
+          "type": "boolean",
+          "default": false
+        },
+        "discriminator": {
+          "$ref": "#/definitions/Discriminator"
+        },
+        "readOnly": {
+          "type": "boolean",
+          "default": false
+        },
+        "writeOnly": {
+          "type": "boolean",
+          "default": false
+        },
+        "example": {},
+        "externalDocs": {
+          "$ref": "#/definitions/ExternalDocumentation"
+        },
+        "deprecated": {
+          "type": "boolean",
+          "default": false
+        },
+        "xml": {
+          "$ref": "#/definitions/XML"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Discriminator": {
+      "type": "object",
+      "required": [
+        "propertyName"
+      ],
+      "properties": {
+        "propertyName": {
+          "type": "string"
+        },
+        "mapping": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "XML": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "namespace": {
+          "type": "string",
+          "format": "uri"
+        },
+        "prefix": {
+          "type": "string"
+        },
+        "attribute": {
+          "type": "boolean",
+          "default": false
+        },
+        "wrapped": {
+          "type": "boolean",
+          "default": false
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Response": {
+      "type": "object",
+      "required": [
+        "description"
+      ],
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "headers": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Header"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "content": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/MediaType"
+          }
+        },
+        "links": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Link"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "MediaType": {
+      "type": "object",
+      "properties": {
+        "schema": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Schema"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        },
+        "example": {},
+        "examples": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Example"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "encoding": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/Encoding"
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "$ref": "#/definitions/ExampleXORExamples"
+        }
+      ]
+    },
+    "Example": {
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "value": {},
+        "externalValue": {
+          "type": "string",
+          "format": "uri-reference"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Header": {
+      "type": "object",
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "required": {
+          "type": "boolean",
+          "default": false
+        },
+        "deprecated": {
+          "type": "boolean",
+          "default": false
+        },
+        "allowEmptyValue": {
+          "type": "boolean",
+          "default": false
+        },
+        "style": {
+          "type": "string",
+          "enum": [
+            "simple"
+          ],
+          "default": "simple"
+        },
+        "explode": {
+          "type": "boolean"
+        },
+        "allowReserved": {
+          "type": "boolean",
+          "default": false
+        },
+        "schema": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Schema"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        },
+        "content": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/MediaType"
+          },
+          "minProperties": 1,
+          "maxProperties": 1
+        },
+        "example": {},
+        "examples": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Example"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "$ref": "#/definitions/ExampleXORExamples"
+        },
+        {
+          "$ref": "#/definitions/SchemaXORContent"
+        }
+      ]
+    },
+    "Paths": {
+      "type": "object",
+      "patternProperties": {
+        "^\\/": {
+          "$ref": "#/definitions/PathItem"
+        },
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "PathItem": {
+      "type": "object",
+      "properties": {
+        "$ref": {
+          "type": "string"
+        },
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "get": {
+          "$ref": "#/definitions/Operation"
+        },
+        "put": {
+          "$ref": "#/definitions/Operation"
+        },
+        "post": {
+          "$ref": "#/definitions/Operation"
+        },
+        "delete": {
+          "$ref": "#/definitions/Operation"
+        },
+        "options": {
+          "$ref": "#/definitions/Operation"
+        },
+        "head": {
+          "$ref": "#/definitions/Operation"
+        },
+        "patch": {
+          "$ref": "#/definitions/Operation"
+        },
+        "trace": {
+          "$ref": "#/definitions/Operation"
+        },
+        "servers": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Server"
+          }
+        },
+        "parameters": {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Parameter"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          },
+          "uniqueItems": true
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Operation": {
+      "type": "object",
+      "required": [
+        "responses"
+      ],
+      "properties": {
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "externalDocs": {
+          "$ref": "#/definitions/ExternalDocumentation"
+        },
+        "operationId": {
+          "type": "string"
+        },
+        "parameters": {
+          "type": "array",
+          "items": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Parameter"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          },
+          "uniqueItems": true
+        },
+        "requestBody": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/RequestBody"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        },
+        "responses": {
+          "$ref": "#/definitions/Responses"
+        },
+        "callbacks": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Callback"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "deprecated": {
+          "type": "boolean",
+          "default": false
+        },
+        "security": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/SecurityRequirement"
+          }
+        },
+        "servers": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Server"
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Responses": {
+      "type": "object",
+      "properties": {
+        "default": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Response"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        }
+      },
+      "patternProperties": {
+        "^[1-5](?:\\d{2}|XX)$": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Response"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        },
+        "^x-": {}
+      },
+      "minProperties": 1,
+      "additionalProperties": false
+    },
+    "SecurityRequirement": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "Tag": {
+      "type": "object",
+      "required": [
+        "name"
+      ],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "externalDocs": {
+          "$ref": "#/definitions/ExternalDocumentation"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "ExternalDocumentation": {
+      "type": "object",
+      "required": [
+        "url"
+      ],
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri-reference"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "ExampleXORExamples": {
+      "description": "Example and examples are mutually exclusive",
+      "not": {
+        "required": [
+          "example",
+          "examples"
+        ]
+      }
+    },
+    "SchemaXORContent": {
+      "description": "Schema and content are mutually exclusive, at least one is required",
+      "not": {
+        "required": [
+          "schema",
+          "content"
+        ]
+      },
+      "oneOf": [
+        {
+          "required": [
+            "schema"
+          ]
+        },
+        {
+          "required": [
+            "content"
+          ],
+          "description": "Some properties are not allowed if content is present",
+          "allOf": [
+            {
+              "not": {
+                "required": [
+                  "style"
+                ]
+              }
+            },
+            {
+              "not": {
+                "required": [
+                  "explode"
+                ]
+              }
+            },
+            {
+              "not": {
+                "required": [
+                  "allowReserved"
+                ]
+              }
+            },
+            {
+              "not": {
+                "required": [
+                  "example"
+                ]
+              }
+            },
+            {
+              "not": {
+                "required": [
+                  "examples"
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "Parameter": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "in": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "required": {
+          "type": "boolean",
+          "default": false
+        },
+        "deprecated": {
+          "type": "boolean",
+          "default": false
+        },
+        "allowEmptyValue": {
+          "type": "boolean",
+          "default": false
+        },
+        "style": {
+          "type": "string"
+        },
+        "explode": {
+          "type": "boolean"
+        },
+        "allowReserved": {
+          "type": "boolean",
+          "default": false
+        },
+        "schema": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Schema"
+            },
+            {
+              "$ref": "#/definitions/Reference"
+            }
+          ]
+        },
+        "content": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/MediaType"
+          },
+          "minProperties": 1,
+          "maxProperties": 1
+        },
+        "example": {},
+        "examples": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Example"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false,
+      "required": [
+        "name",
+        "in"
+      ],
+      "allOf": [
+        {
+          "$ref": "#/definitions/ExampleXORExamples"
+        },
+        {
+          "$ref": "#/definitions/SchemaXORContent"
+        }
+      ],
+      "oneOf": [
+        {
+          "$ref": "#/definitions/PathParameter"
+        },
+        {
+          "$ref": "#/definitions/QueryParameter"
+        },
+        {
+          "$ref": "#/definitions/HeaderParameter"
+        },
+        {
+          "$ref": "#/definitions/CookieParameter"
+        }
+      ]
+    },
+    "PathParameter": {
+      "description": "Parameter in path",
+      "required": [
+        "required"
+      ],
+      "properties": {
+        "in": {
+          "enum": [
+            "path"
+          ]
+        },
+        "style": {
+          "enum": [
+            "matrix",
+            "label",
+            "simple"
+          ],
+          "default": "simple"
+        },
+        "required": {
+          "enum": [
+            true
+          ]
+        }
+      }
+    },
+    "QueryParameter": {
+      "description": "Parameter in query",
+      "properties": {
+        "in": {
+          "enum": [
+            "query"
+          ]
+        },
+        "style": {
+          "enum": [
+            "form",
+            "spaceDelimited",
+            "pipeDelimited",
+            "deepObject"
+          ],
+          "default": "form"
+        }
+      }
+    },
+    "HeaderParameter": {
+      "description": "Parameter in header",
+      "properties": {
+        "in": {
+          "enum": [
+            "header"
+          ]
+        },
+        "style": {
+          "enum": [
+            "simple"
+          ],
+          "default": "simple"
+        }
+      }
+    },
+    "CookieParameter": {
+      "description": "Parameter in cookie",
+      "properties": {
+        "in": {
+          "enum": [
+            "cookie"
+          ]
+        },
+        "style": {
+          "enum": [
+            "form"
+          ],
+          "default": "form"
+        }
+      }
+    },
+    "RequestBody": {
+      "type": "object",
+      "required": [
+        "content"
+      ],
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "content": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/MediaType"
+          }
+        },
+        "required": {
+          "type": "boolean",
+          "default": false
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "SecurityScheme": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/APIKeySecurityScheme"
+        },
+        {
+          "$ref": "#/definitions/HTTPSecurityScheme"
+        },
+        {
+          "$ref": "#/definitions/OAuth2SecurityScheme"
+        },
+        {
+          "$ref": "#/definitions/OpenIdConnectSecurityScheme"
+        }
+      ]
+    },
+    "APIKeySecurityScheme": {
+      "type": "object",
+      "required": [
+        "type",
+        "name",
+        "in"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "apiKey"
+          ]
+        },
+        "name": {
+          "type": "string"
+        },
+        "in": {
+          "type": "string",
+          "enum": [
+            "header",
+            "query",
+            "cookie"
+          ]
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "HTTPSecurityScheme": {
+      "type": "object",
+      "required": [
+        "scheme",
+        "type"
+      ],
+      "properties": {
+        "scheme": {
+          "type": "string"
+        },
+        "bearerFormat": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "http"
+          ]
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false,
+      "oneOf": [
+        {
+          "description": "Bearer",
+          "properties": {
+            "scheme": {
+              "type": "string",
+              "pattern": "^[Bb][Ee][Aa][Rr][Ee][Rr]$"
+            }
+          }
+        },
+        {
+          "description": "Non Bearer",
+          "not": {
+            "required": [
+              "bearerFormat"
+            ]
+          },
+          "properties": {
+            "scheme": {
+              "not": {
+                "type": "string",
+                "pattern": "^[Bb][Ee][Aa][Rr][Ee][Rr]$"
+              }
+            }
+          }
+        }
+      ]
+    },
+    "OAuth2SecurityScheme": {
+      "type": "object",
+      "required": [
+        "type",
+        "flows"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "oauth2"
+          ]
+        },
+        "flows": {
+          "$ref": "#/definitions/OAuthFlows"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "OpenIdConnectSecurityScheme": {
+      "type": "object",
+      "required": [
+        "type",
+        "openIdConnectUrl"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [
+            "openIdConnect"
+          ]
+        },
+        "openIdConnectUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "OAuthFlows": {
+      "type": "object",
+      "properties": {
+        "implicit": {
+          "$ref": "#/definitions/ImplicitOAuthFlow"
+        },
+        "password": {
+          "$ref": "#/definitions/PasswordOAuthFlow"
+        },
+        "clientCredentials": {
+          "$ref": "#/definitions/ClientCredentialsFlow"
+        },
+        "authorizationCode": {
+          "$ref": "#/definitions/AuthorizationCodeOAuthFlow"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "ImplicitOAuthFlow": {
+      "type": "object",
+      "required": [
+        "authorizationUrl",
+        "scopes"
+      ],
+      "properties": {
+        "authorizationUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "refreshUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "scopes": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "PasswordOAuthFlow": {
+      "type": "object",
+      "required": [
+        "tokenUrl",
+        "scopes"
+      ],
+      "properties": {
+        "tokenUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "refreshUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "scopes": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "ClientCredentialsFlow": {
+      "type": "object",
+      "required": [
+        "tokenUrl",
+        "scopes"
+      ],
+      "properties": {
+        "tokenUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "refreshUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "scopes": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "AuthorizationCodeOAuthFlow": {
+      "type": "object",
+      "required": [
+        "authorizationUrl",
+        "tokenUrl",
+        "scopes"
+      ],
+      "properties": {
+        "authorizationUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "tokenUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "refreshUrl": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "scopes": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    },
+    "Link": {
+      "type": "object",
+      "properties": {
+        "operationId": {
+          "type": "string"
+        },
+        "operationRef": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "parameters": {
+          "type": "object",
+          "additionalProperties": {}
+        },
+        "requestBody": {},
+        "description": {
+          "type": "string"
+        },
+        "server": {
+          "$ref": "#/definitions/Server"
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false,
+      "not": {
+        "description": "Operation Id and Operation Ref are mutually exclusive",
+        "required": [
+          "operationId",
+          "operationRef"
+        ]
+      }
+    },
+    "Callback": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/PathItem"
+      },
+      "patternProperties": {
+        "^x-": {}
+      }
+    },
+    "Encoding": {
+      "type": "object",
+      "properties": {
+        "contentType": {
+          "type": "string"
+        },
+        "headers": {
+          "type": "object",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Header"
+              },
+              {
+                "$ref": "#/definitions/Reference"
+              }
+            ]
+          }
+        },
+        "style": {
+          "type": "string",
+          "enum": [
+            "form",
+            "spaceDelimited",
+            "pipeDelimited",
+            "deepObject"
+          ]
+        },
+        "explode": {
+          "type": "boolean"
+        },
+        "allowReserved": {
+          "type": "boolean",
+          "default": false
+        }
+      },
+      "patternProperties": {
+        "^x-": {}
+      },
+      "additionalProperties": false
+    }
+  }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.3.1.json b/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.3.1.json
new file mode 100644
index 0000000000..744f94a788
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/schemas/schema.3.1.json
@@ -0,0 +1,1411 @@
+{
+  "$id": "https://spec.openapis.org/oas/3.1/schema/2025-09-15",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "The description of OpenAPI v3.1.x Documents without Schema Object validation",
+  "type": "object",
+  "properties": {
+    "openapi": {
+      "type": "string",
+      "pattern": "^3\\.1\\.\\d+(-.+)?$"
+    },
+    "info": {
+      "$ref": "#/$defs/info"
+    },
+    "jsonSchemaDialect": {
+      "type": "string",
+      "format": "uri-reference",
+      "default": "https://spec.openapis.org/oas/3.1/dialect/2024-11-10"
+    },
+    "servers": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/server"
+      },
+      "default": [
+        {
+          "url": "/"
+        }
+      ]
+    },
+    "paths": {
+      "$ref": "#/$defs/paths"
+    },
+    "webhooks": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/$defs/path-item"
+      }
+    },
+    "components": {
+      "$ref": "#/$defs/components"
+    },
+    "security": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/security-requirement"
+      }
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/tag"
+      }
+    },
+    "externalDocs": {
+      "$ref": "#/$defs/external-documentation"
+    }
+  },
+  "required": [
+    "openapi",
+    "info"
+  ],
+  "anyOf": [
+    {
+      "required": [
+        "paths"
+      ]
+    },
+    {
+      "required": [
+        "components"
+      ]
+    },
+    {
+      "required": [
+        "webhooks"
+      ]
+    }
+  ],
+  "$ref": "#/$defs/specification-extensions",
+  "unevaluatedProperties": false,
+  "$defs": {
+    "info": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#info-object",
+      "type": "object",
+      "properties": {
+        "title": {
+          "type": "string"
+        },
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "termsOfService": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "contact": {
+          "$ref": "#/$defs/contact"
+        },
+        "license": {
+          "$ref": "#/$defs/license"
+        },
+        "version": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "title",
+        "version"
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "contact": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#contact-object",
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "email": {
+          "type": "string",
+          "format": "email"
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "license": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#license-object",
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "identifier": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri-reference"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "dependentSchemas": {
+        "identifier": {
+          "not": {
+            "required": [
+              "url"
+            ]
+          }
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "server": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#server-object",
+      "type": "object",
+      "properties": {
+        "url": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "variables": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/server-variable"
+          }
+        }
+      },
+      "required": [
+        "url"
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "server-variable": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#server-variable-object",
+      "type": "object",
+      "properties": {
+        "enum": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "minItems": 1
+        },
+        "default": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "default"
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "components": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#components-object",
+      "type": "object",
+      "properties": {
+        "schemas": {
+          "type": "object",
+          "additionalProperties": {
+            "$dynamicRef": "#meta"
+          }
+        },
+        "responses": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/response-or-reference"
+          }
+        },
+        "parameters": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/parameter-or-reference"
+          }
+        },
+        "examples": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/example-or-reference"
+          }
+        },
+        "requestBodies": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/request-body-or-reference"
+          }
+        },
+        "headers": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/header-or-reference"
+          }
+        },
+        "securitySchemes": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/security-scheme-or-reference"
+          }
+        },
+        "links": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/link-or-reference"
+          }
+        },
+        "callbacks": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/callbacks-or-reference"
+          }
+        },
+        "pathItems": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/path-item"
+          }
+        }
+      },
+      "patternProperties": {
+        "^(?:schemas|responses|parameters|examples|requestBodies|headers|securitySchemes|links|callbacks|pathItems)$": {
+          "$comment": "Enumerating all of the property names in the regex above is necessary for unevaluatedProperties to work as expected",
+          "propertyNames": {
+            "pattern": "^[a-zA-Z0-9._-]+$"
+          }
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "paths": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#paths-object",
+      "type": "object",
+      "patternProperties": {
+        "^/": {
+          "$ref": "#/$defs/path-item"
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "path-item": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#path-item-object",
+      "type": "object",
+      "properties": {
+        "$ref": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "servers": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/server"
+          }
+        },
+        "parameters": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/parameter-or-reference"
+          }
+        },
+        "get": {
+          "$ref": "#/$defs/operation"
+        },
+        "put": {
+          "$ref": "#/$defs/operation"
+        },
+        "post": {
+          "$ref": "#/$defs/operation"
+        },
+        "delete": {
+          "$ref": "#/$defs/operation"
+        },
+        "options": {
+          "$ref": "#/$defs/operation"
+        },
+        "head": {
+          "$ref": "#/$defs/operation"
+        },
+        "patch": {
+          "$ref": "#/$defs/operation"
+        },
+        "trace": {
+          "$ref": "#/$defs/operation"
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "operation": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#operation-object",
+      "type": "object",
+      "properties": {
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "externalDocs": {
+          "$ref": "#/$defs/external-documentation"
+        },
+        "operationId": {
+          "type": "string"
+        },
+        "parameters": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/parameter-or-reference"
+          }
+        },
+        "requestBody": {
+          "$ref": "#/$defs/request-body-or-reference"
+        },
+        "responses": {
+          "$ref": "#/$defs/responses"
+        },
+        "callbacks": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/callbacks-or-reference"
+          }
+        },
+        "deprecated": {
+          "default": false,
+          "type": "boolean"
+        },
+        "security": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/security-requirement"
+          }
+        },
+        "servers": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/server"
+          }
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "external-documentation": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#external-documentation-object",
+      "type": "object",
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri-reference"
+        }
+      },
+      "required": [
+        "url"
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "parameter": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#parameter-object",
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "in": {
+          "enum": [
+            "query",
+            "header",
+            "path",
+            "cookie"
+          ]
+        },
+        "description": {
+          "type": "string"
+        },
+        "required": {
+          "default": false,
+          "type": "boolean"
+        },
+        "deprecated": {
+          "default": false,
+          "type": "boolean"
+        },
+        "schema": {
+          "$dynamicRef": "#meta"
+        },
+        "content": {
+          "$ref": "#/$defs/content",
+          "minProperties": 1,
+          "maxProperties": 1
+        }
+      },
+      "required": [
+        "name",
+        "in"
+      ],
+      "oneOf": [
+        {
+          "required": [
+            "schema"
+          ]
+        },
+        {
+          "required": [
+            "content"
+          ]
+        }
+      ],
+      "if": {
+        "properties": {
+          "in": {
+            "const": "query"
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "allowEmptyValue": {
+            "default": false,
+            "type": "boolean"
+          }
+        }
+      },
+      "dependentSchemas": {
+        "schema": {
+          "properties": {
+            "style": {
+              "type": "string"
+            },
+            "explode": {
+              "type": "boolean"
+            }
+          },
+          "allOf": [
+            {
+              "$ref": "#/$defs/examples"
+            },
+            {
+              "$ref": "#/$defs/parameter/dependentSchemas/schema/$defs/styles-for-path"
+            },
+            {
+              "$ref": "#/$defs/parameter/dependentSchemas/schema/$defs/styles-for-header"
+            },
+            {
+              "$ref": "#/$defs/parameter/dependentSchemas/schema/$defs/styles-for-query"
+            },
+            {
+              "$ref": "#/$defs/parameter/dependentSchemas/schema/$defs/styles-for-cookie"
+            },
+            {
+              "$ref": "#/$defs/styles-for-form"
+            }
+          ],
+          "$defs": {
+            "styles-for-path": {
+              "if": {
+                "properties": {
+                  "in": {
+                    "const": "path"
+                  }
+                }
+              },
+              "then": {
+                "properties": {
+                  "style": {
+                    "default": "simple",
+                    "enum": [
+                      "matrix",
+                      "label",
+                      "simple"
+                    ]
+                  },
+                  "required": {
+                    "const": true
+                  }
+                },
+                "required": [
+                  "required"
+                ]
+              }
+            },
+            "styles-for-header": {
+              "if": {
+                "properties": {
+                  "in": {
+                    "const": "header"
+                  }
+                }
+              },
+              "then": {
+                "properties": {
+                  "style": {
+                    "default": "simple",
+                    "const": "simple"
+                  }
+                }
+              }
+            },
+            "styles-for-query": {
+              "if": {
+                "properties": {
+                  "in": {
+                    "const": "query"
+                  }
+                }
+              },
+              "then": {
+                "properties": {
+                  "style": {
+                    "default": "form",
+                    "enum": [
+                      "form",
+                      "spaceDelimited",
+                      "pipeDelimited",
+                      "deepObject"
+                    ]
+                  },
+                  "allowReserved": {
+                    "default": false,
+                    "type": "boolean"
+                  }
+                }
+              }
+            },
+            "styles-for-cookie": {
+              "if": {
+                "properties": {
+                  "in": {
+                    "const": "cookie"
+                  }
+                }
+              },
+              "then": {
+                "properties": {
+                  "style": {
+                    "default": "form",
+                    "const": "form"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "parameter-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/parameter"
+      }
+    },
+    "request-body": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#request-body-object",
+      "type": "object",
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "content": {
+          "$ref": "#/$defs/content"
+        },
+        "required": {
+          "default": false,
+          "type": "boolean"
+        }
+      },
+      "required": [
+        "content"
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "request-body-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/request-body"
+      }
+    },
+    "content": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#fixed-fields-10",
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/$defs/media-type"
+      },
+      "propertyNames": {
+        "format": "media-range"
+      }
+    },
+    "media-type": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#media-type-object",
+      "type": "object",
+      "properties": {
+        "schema": {
+          "$dynamicRef": "#meta"
+        },
+        "encoding": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/encoding"
+          }
+        }
+      },
+      "allOf": [
+        {
+          "$ref": "#/$defs/specification-extensions"
+        },
+        {
+          "$ref": "#/$defs/examples"
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "encoding": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#encoding-object",
+      "type": "object",
+      "properties": {
+        "contentType": {
+          "type": "string",
+          "format": "media-range"
+        },
+        "headers": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/header-or-reference"
+          }
+        },
+        "style": {
+          "enum": [
+            "form",
+            "spaceDelimited",
+            "pipeDelimited",
+            "deepObject"
+          ]
+        },
+        "explode": {
+          "type": "boolean"
+        },
+        "allowReserved": {
+          "type": "boolean"
+        }
+      },
+      "dependentSchemas": {
+        "style": {
+          "properties": {
+            "allowReserved": {
+              "default": false
+            }
+          }
+        },
+        "explode": {
+          "properties": {
+            "style": {
+              "default": "form"
+            },
+            "allowReserved": {
+              "default": false
+            }
+          }
+        },
+        "allowReserved": {
+          "properties": {
+            "style": {
+              "default": "form"
+            }
+          }
+        }
+      },
+      "allOf": [
+        {
+          "$ref": "#/$defs/specification-extensions"
+        },
+        {
+          "$ref": "#/$defs/styles-for-form"
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "responses": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#responses-object",
+      "type": "object",
+      "properties": {
+        "default": {
+          "$ref": "#/$defs/response-or-reference"
+        }
+      },
+      "patternProperties": {
+        "^[1-5](?:[0-9]{2}|XX)$": {
+          "$ref": "#/$defs/response-or-reference"
+        }
+      },
+      "minProperties": 1,
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false,
+      "if": {
+        "$comment": "either default, or at least one response code property must exist",
+        "patternProperties": {
+          "^[1-5](?:[0-9]{2}|XX)$": false
+        }
+      },
+      "then": {
+        "required": [
+          "default"
+        ]
+      }
+    },
+    "response": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#response-object",
+      "type": "object",
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "headers": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/header-or-reference"
+          }
+        },
+        "content": {
+          "$ref": "#/$defs/content"
+        },
+        "links": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/link-or-reference"
+          }
+        }
+      },
+      "required": [
+        "description"
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "response-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/response"
+      }
+    },
+    "callbacks": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#callback-object",
+      "type": "object",
+      "$ref": "#/$defs/specification-extensions",
+      "additionalProperties": {
+        "$ref": "#/$defs/path-item"
+      }
+    },
+    "callbacks-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/callbacks"
+      }
+    },
+    "example": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#example-object",
+      "type": "object",
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "value": true,
+        "externalValue": {
+          "type": "string",
+          "format": "uri-reference"
+        }
+      },
+      "not": {
+        "required": [
+          "value",
+          "externalValue"
+        ]
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "example-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/example"
+      }
+    },
+    "link": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#link-object",
+      "type": "object",
+      "properties": {
+        "operationRef": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "operationId": {
+          "type": "string"
+        },
+        "parameters": {
+          "$ref": "#/$defs/map-of-strings"
+        },
+        "requestBody": true,
+        "description": {
+          "type": "string"
+        },
+        "server": {
+          "$ref": "#/$defs/server"
+        }
+      },
+      "oneOf": [
+        {
+          "required": [
+            "operationRef"
+          ]
+        },
+        {
+          "required": [
+            "operationId"
+          ]
+        }
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "link-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/link"
+      }
+    },
+    "header": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#header-object",
+      "type": "object",
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "required": {
+          "default": false,
+          "type": "boolean"
+        },
+        "deprecated": {
+          "default": false,
+          "type": "boolean"
+        },
+        "schema": {
+          "$dynamicRef": "#meta"
+        },
+        "content": {
+          "$ref": "#/$defs/content",
+          "minProperties": 1,
+          "maxProperties": 1
+        }
+      },
+      "oneOf": [
+        {
+          "required": [
+            "schema"
+          ]
+        },
+        {
+          "required": [
+            "content"
+          ]
+        }
+      ],
+      "dependentSchemas": {
+        "schema": {
+          "properties": {
+            "style": {
+              "default": "simple",
+              "const": "simple"
+            },
+            "explode": {
+              "default": false,
+              "type": "boolean"
+            }
+          },
+          "$ref": "#/$defs/examples"
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "header-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/header"
+      }
+    },
+    "tag": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#tag-object",
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "externalDocs": {
+          "$ref": "#/$defs/external-documentation"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false
+    },
+    "reference": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#reference-object",
+      "type": "object",
+      "properties": {
+        "$ref": {
+          "type": "string",
+          "format": "uri-reference"
+        },
+        "summary": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        }
+      }
+    },
+    "schema": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#schema-object",
+      "$dynamicAnchor": "meta",
+      "type": [
+        "object",
+        "boolean"
+      ]
+    },
+    "security-scheme": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#security-scheme-object",
+      "type": "object",
+      "properties": {
+        "type": {
+          "enum": [
+            "apiKey",
+            "http",
+            "mutualTLS",
+            "oauth2",
+            "openIdConnect"
+          ]
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "type"
+      ],
+      "allOf": [
+        {
+          "$ref": "#/$defs/specification-extensions"
+        },
+        {
+          "$ref": "#/$defs/security-scheme/$defs/type-apikey"
+        },
+        {
+          "$ref": "#/$defs/security-scheme/$defs/type-http"
+        },
+        {
+          "$ref": "#/$defs/security-scheme/$defs/type-http-bearer"
+        },
+        {
+          "$ref": "#/$defs/security-scheme/$defs/type-oauth2"
+        },
+        {
+          "$ref": "#/$defs/security-scheme/$defs/type-oidc"
+        }
+      ],
+      "unevaluatedProperties": false,
+      "$defs": {
+        "type-apikey": {
+          "if": {
+            "properties": {
+              "type": {
+                "const": "apiKey"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "name": {
+                "type": "string"
+              },
+              "in": {
+                "enum": [
+                  "query",
+                  "header",
+                  "cookie"
+                ]
+              }
+            },
+            "required": [
+              "name",
+              "in"
+            ]
+          }
+        },
+        "type-http": {
+          "if": {
+            "properties": {
+              "type": {
+                "const": "http"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "scheme": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "scheme"
+            ]
+          }
+        },
+        "type-http-bearer": {
+          "if": {
+            "properties": {
+              "type": {
+                "const": "http"
+              },
+              "scheme": {
+                "type": "string",
+                "pattern": "^[Bb][Ee][Aa][Rr][Ee][Rr]$"
+              }
+            },
+            "required": [
+              "type",
+              "scheme"
+            ]
+          },
+          "then": {
+            "properties": {
+              "bearerFormat": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "type-oauth2": {
+          "if": {
+            "properties": {
+              "type": {
+                "const": "oauth2"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "flows": {
+                "$ref": "#/$defs/oauth-flows"
+              }
+            },
+            "required": [
+              "flows"
+            ]
+          }
+        },
+        "type-oidc": {
+          "if": {
+            "properties": {
+              "type": {
+                "const": "openIdConnect"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "openIdConnectUrl": {
+                "type": "string",
+                "format": "uri-reference"
+              }
+            },
+            "required": [
+              "openIdConnectUrl"
+            ]
+          }
+        }
+      }
+    },
+    "security-scheme-or-reference": {
+      "if": {
+        "type": "object",
+        "required": [
+          "$ref"
+        ]
+      },
+      "then": {
+        "$ref": "#/$defs/reference"
+      },
+      "else": {
+        "$ref": "#/$defs/security-scheme"
+      }
+    },
+    "oauth-flows": {
+      "type": "object",
+      "properties": {
+        "implicit": {
+          "$ref": "#/$defs/oauth-flows/$defs/implicit"
+        },
+        "password": {
+          "$ref": "#/$defs/oauth-flows/$defs/password"
+        },
+        "clientCredentials": {
+          "$ref": "#/$defs/oauth-flows/$defs/client-credentials"
+        },
+        "authorizationCode": {
+          "$ref": "#/$defs/oauth-flows/$defs/authorization-code"
+        }
+      },
+      "$ref": "#/$defs/specification-extensions",
+      "unevaluatedProperties": false,
+      "$defs": {
+        "implicit": {
+          "type": "object",
+          "properties": {
+            "authorizationUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "refreshUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "scopes": {
+              "$ref": "#/$defs/map-of-strings"
+            }
+          },
+          "required": [
+            "authorizationUrl",
+            "scopes"
+          ],
+          "$ref": "#/$defs/specification-extensions",
+          "unevaluatedProperties": false
+        },
+        "password": {
+          "type": "object",
+          "properties": {
+            "tokenUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "refreshUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "scopes": {
+              "$ref": "#/$defs/map-of-strings"
+            }
+          },
+          "required": [
+            "tokenUrl",
+            "scopes"
+          ],
+          "$ref": "#/$defs/specification-extensions",
+          "unevaluatedProperties": false
+        },
+        "client-credentials": {
+          "type": "object",
+          "properties": {
+            "tokenUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "refreshUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "scopes": {
+              "$ref": "#/$defs/map-of-strings"
+            }
+          },
+          "required": [
+            "tokenUrl",
+            "scopes"
+          ],
+          "$ref": "#/$defs/specification-extensions",
+          "unevaluatedProperties": false
+        },
+        "authorization-code": {
+          "type": "object",
+          "properties": {
+            "authorizationUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "tokenUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "refreshUrl": {
+              "type": "string",
+              "format": "uri-reference"
+            },
+            "scopes": {
+              "$ref": "#/$defs/map-of-strings"
+            }
+          },
+          "required": [
+            "authorizationUrl",
+            "tokenUrl",
+            "scopes"
+          ],
+          "$ref": "#/$defs/specification-extensions",
+          "unevaluatedProperties": false
+        }
+      }
+    },
+    "security-requirement": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#security-requirement-object",
+      "type": "object",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "specification-extensions": {
+      "$comment": "https://spec.openapis.org/oas/v3.1#specification-extensions",
+      "patternProperties": {
+        "^x-": {}
+      }
+    },
+    "examples": {
+      "properties": {
+        "example": true,
+        "examples": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/example-or-reference"
+          }
+        }
+      },
+      "not": {
+        "required": [
+          "example",
+          "examples"
+        ]
+      }
+    },
+    "map-of-strings": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "styles-for-form": {
+      "if": {
+        "properties": {
+          "style": {
+            "const": "form"
+          }
+        },
+        "required": [
+          "style"
+        ]
+      },
+      "then": {
+        "properties": {
+          "explode": {
+            "default": true
+          }
+        }
+      },
+      "else": {
+        "properties": {
+          "explode": {
+            "default": false
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/ApiRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/ApiRequestBuilder.verified.cs
new file mode 100644
index 0000000000..3089b919fb
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/ApiRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+using TodoApp.Client.Api.Items;
+namespace TodoApp.Client.Api
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The items property</summary>
+        public global::TodoApp.Client.Api.Items.ItemsRequestBuilder Items
+        {
+            get => new global::TodoApp.Client.Api.Items.ItemsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Find/FindRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Find/FindRequestBuilder.verified.cs
new file mode 100644
index 0000000000..1e6da55fa3
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Find/FindRequestBuilder.verified.cs
@@ -0,0 +1,94 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Find
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\find
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FindRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Find.FindRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FindRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/find?IsCompleted={IsCompleted}&Text={Text}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Find.FindRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FindRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/find?IsCompleted={IsCompleted}&Text={Text}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoListViewModel>(requestInfo, global::TodoApp.Client.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Find.FindRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Find.FindRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Find.FindRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class FindRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            /// <summary>Gets or sets a value indicating whether to search completed Todo items.</summary>
+            public bool? IsCompleted { get; set; }
+            /// <summary>Gets or sets the text of the filter.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public string? Text { get; set; }
+#nullable restore
+#else
+            public string Text { get; set; }
+#endif
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/GetAfter/GetAfterRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/GetAfter/GetAfterRequestBuilder.verified.cs
new file mode 100644
index 0000000000..d420636015
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/GetAfter/GetAfterRequestBuilder.verified.cs
@@ -0,0 +1,86 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.GetAfter
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\getAfter
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class GetAfterRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetAfterRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/getAfter?value={value}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetAfterRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/getAfter?value={value}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoListViewModel>(requestInfo, global::TodoApp.Client.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class GetAfterRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            [QueryParameter("value")]
+            public DateTimeOffset? Value { get; set; }
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/Complete/CompleteRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/Complete/CompleteRequestBuilder.verified.cs
new file mode 100644
index 0000000000..09e8901d32
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/Complete/CompleteRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Item.Complete
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}\complete
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CompleteRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CompleteRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/complete", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CompleteRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/complete", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Marks the todo item with the specified ID as complete.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 400 status code</exception>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PostAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PostAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToPostRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Marks the todo item with the specified ID as complete.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/ItemsItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/ItemsItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e3acec88bd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/ItemsItemRequestBuilder.verified.cs
@@ -0,0 +1,142 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Api.Items.Item.Complete;
+using TodoApp.Client.Api.Items.Item.Priority;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ItemsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The complete property</summary>
+        public global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder Complete
+        {
+            get => new global::TodoApp.Client.Api.Items.Item.Complete.CompleteRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The priority property</summary>
+        public global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder Priority
+        {
+            get => new global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Deletes the todo item with the specified ID.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Gets the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoItemModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoItemModel?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoItemModel> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoItemModel>(requestInfo, global::TodoApp.Client.Models.TodoItemModel.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Deletes the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Gets the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/Priority/PriorityRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/Priority/PriorityRequestBuilder.verified.cs
new file mode 100644
index 0000000000..6df4f2ccf7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/Item/Priority/PriorityRequestBuilder.verified.cs
@@ -0,0 +1,95 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items.Item.Priority
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}\priority
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class PriorityRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PriorityRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/priority", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PriorityRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/priority", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </summary>
+        /// <param name="body">Represents the model for updating the priority of a Todo item.</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 400 status code</exception>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PatchAsync(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PatchAsync(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPatchRequestInformation(body, requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+                { "404", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents the model for updating the priority of a Todo item.</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPatchRequestInformation(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPatchRequestInformation(global::TodoApp.Client.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PATCH, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.Item.Priority.PriorityRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/ItemsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/ItemsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..af6df99c5b
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Api/Items/ItemsRequestBuilder.verified.cs
@@ -0,0 +1,156 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+using TodoApp.Client.Api.Items.Find;
+using TodoApp.Client.Api.Items.GetAfter;
+using TodoApp.Client.Api.Items.Item;
+using TodoApp.Client.Models;
+namespace TodoApp.Client.Api.Items
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ItemsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The find property</summary>
+        public global::TodoApp.Client.Api.Items.Find.FindRequestBuilder Find
+        {
+            get => new global::TodoApp.Client.Api.Items.Find.FindRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The getAfter property</summary>
+        public global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder GetAfter
+        {
+            get => new global::TodoApp.Client.Api.Items.GetAfter.GetAfterRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>Gets an item from the TodoApp.Client.api.items.item collection</summary>
+        /// <param name="position">The Todo item&apos;s ID.</param>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder"/></returns>
+        public global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder this[Guid position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::TodoApp.Client.Api.Items.Item.ItemsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.ItemsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.Api.Items.ItemsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Gets all of the current user&apos;s todo items.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.TodoListViewModel>(requestInfo, global::TodoApp.Client.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.CreatedTodoItemModel"/></returns>
+        /// <param name="body">Represents the model for creating a new Todo item.</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::TodoApp.Client.Models.ProblemDetails">When receiving a 400 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::TodoApp.Client.Models.CreatedTodoItemModel?> PostAsync(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::TodoApp.Client.Models.CreatedTodoItemModel> PostAsync(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::TodoApp.Client.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::TodoApp.Client.Models.CreatedTodoItemModel>(requestInfo, global::TodoApp.Client.Models.CreatedTodoItemModel.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Gets all of the current user&apos;s todo items.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents the model for creating a new Todo item.</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::TodoApp.Client.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Api.Items.ItemsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::TodoApp.Client.Api.Items.ItemsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::TodoApp.Client.Api.Items.ItemsRequestBuilder(rawUrl, RequestAdapter);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/CreateTodoItemModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/CreateTodoItemModel.verified.cs
new file mode 100644
index 0000000000..facd4f1345
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/CreateTodoItemModel.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents the model for creating a new Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CreateTodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the text of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Text { get; set; }
+#nullable restore
+#else
+        public string Text { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.CreateTodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.CreateTodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.CreateTodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "text", n => { Text = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("text", Text);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/CreatedTodoItemModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/CreatedTodoItemModel.verified.cs
new file mode 100644
index 0000000000..ab6ca282e9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/CreatedTodoItemModel.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents the model for a created Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CreatedTodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the ID of the created Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Id { get; set; }
+#nullable restore
+#else
+        public string Id { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.CreatedTodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.CreatedTodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.CreatedTodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "id", n => { Id = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/ProblemDetails.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/ProblemDetails.verified.cs
new file mode 100644
index 0000000000..1773cc90ee
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/ProblemDetails.verified.cs
@@ -0,0 +1,92 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class ProblemDetails : ApiException, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The detail property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Detail { get; set; }
+#nullable restore
+#else
+        public string Detail { get; set; }
+#endif
+        /// <summary>The instance property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Instance { get; set; }
+#nullable restore
+#else
+        public string Instance { get; set; }
+#endif
+        /// <summary>The primary error message.</summary>
+        public override string Message { get => base.Message; }
+        /// <summary>The status property</summary>
+        public int? Status { get; set; }
+        /// <summary>The title property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Title { get; set; }
+#nullable restore
+#else
+        public string Title { get; set; }
+#endif
+        /// <summary>The type property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Type { get; set; }
+#nullable restore
+#else
+        public string Type { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.ProblemDetails"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.ProblemDetails CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.ProblemDetails();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "detail", n => { Detail = n.GetStringValue(); } },
+                { "instance", n => { Instance = n.GetStringValue(); } },
+                { "status", n => { Status = n.GetIntValue(); } },
+                { "title", n => { Title = n.GetStringValue(); } },
+                { "type", n => { Type = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("detail", Detail);
+            writer.WriteStringValue("instance", Instance);
+            writer.WriteIntValue("status", Status);
+            writer.WriteStringValue("title", Title);
+            writer.WriteStringValue("type", Type);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoItemModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoItemModel.verified.cs
new file mode 100644
index 0000000000..f9e6233aca
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoItemModel.verified.cs
@@ -0,0 +1,82 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents a Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the date and time the item was completed.</summary>
+        public DateTimeOffset? CompletedAt { get; set; }
+        /// <summary>Gets or sets the date and time the item was created.</summary>
+        public DateTimeOffset? CreatedAt { get; set; }
+        /// <summary>Gets or sets the ID of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Id { get; set; }
+#nullable restore
+#else
+        public string Id { get; set; }
+#endif
+        /// <summary>Gets or sets the date and time the Todo item was last updated.</summary>
+        public DateTimeOffset? LastUpdated { get; set; }
+        /// <summary>Gets or sets the optional priority of the Todo item.</summary>
+        public global::TodoApp.Client.Models.TodoPriority? Priority { get; set; }
+        /// <summary>Gets or sets the text of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Text { get; set; }
+#nullable restore
+#else
+        public string Text { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.TodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.TodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "completedAt", n => { CompletedAt = n.GetDateTimeOffsetValue(); } },
+                { "createdAt", n => { CreatedAt = n.GetDateTimeOffsetValue(); } },
+                { "id", n => { Id = n.GetStringValue(); } },
+                { "lastUpdated", n => { LastUpdated = n.GetDateTimeOffsetValue(); } },
+                { "priority", n => { Priority = n.GetEnumValue<global::TodoApp.Client.Models.TodoPriority>(); } },
+                { "text", n => { Text = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDateTimeOffsetValue("completedAt", CompletedAt);
+            writer.WriteDateTimeOffsetValue("createdAt", CreatedAt);
+            writer.WriteStringValue("id", Id);
+            writer.WriteDateTimeOffsetValue("lastUpdated", LastUpdated);
+            writer.WriteEnumValue<global::TodoApp.Client.Models.TodoPriority>("priority", Priority);
+            writer.WriteStringValue("text", Text);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoListViewModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoListViewModel.verified.cs
new file mode 100644
index 0000000000..eb520f51c2
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoListViewModel.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents a collection of Todo items.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoListViewModel : IParsable
+    {
+        /// <summary>Gets or sets the Todo item(s).</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public List<global::TodoApp.Client.Models.TodoItemModel>? Items { get; set; }
+#nullable restore
+#else
+        public List<global::TodoApp.Client.Models.TodoItemModel> Items { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.TodoListViewModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.TodoListViewModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.TodoListViewModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "items", n => { Items = n.GetCollectionOfObjectValues<global::TodoApp.Client.Models.TodoItemModel>(global::TodoApp.Client.Models.TodoItemModel.CreateFromDiscriminatorValue)?.AsList(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteCollectionOfObjectValues<global::TodoApp.Client.Models.TodoItemModel>("items", Items);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoPriority.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoPriority.verified.cs
new file mode 100644
index 0000000000..3ff868a37c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/TodoPriority.verified.cs
@@ -0,0 +1,23 @@
+// <auto-generated/>
+using System.Runtime.Serialization;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>The priority levels for a Todo item.</summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public enum TodoPriority
+    {
+        [EnumMember(Value = "Normal")]
+        #pragma warning disable CS1591
+        Normal,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "Low")]
+        #pragma warning disable CS1591
+        Low,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "High")]
+        #pragma warning disable CS1591
+        High,
+        #pragma warning restore CS1591
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/UpdateTodoItemPriorityModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/UpdateTodoItemPriorityModel.verified.cs
new file mode 100644
index 0000000000..7febaace2e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/Models/UpdateTodoItemPriorityModel.verified.cs
@@ -0,0 +1,50 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace TodoApp.Client.Models
+{
+    /// <summary>
+    /// Represents the model for updating the priority of a Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class UpdateTodoItemPriorityModel : IParsable
+    {
+        /// <summary>Gets or sets the new priority of the Todo item.</summary>
+        public global::TodoApp.Client.Models.TodoPriority? Priority { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::TodoApp.Client.Models.UpdateTodoItemPriorityModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::TodoApp.Client.Models.UpdateTodoItemPriorityModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::TodoApp.Client.Models.UpdateTodoItemPriorityModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "priority", n => { Priority = n.GetEnumValue<global::TodoApp.Client.Models.TodoPriority>(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteEnumValue<global::TodoApp.Client.Models.TodoPriority>("priority", Priority);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/TodoApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/TodoApiClient.verified.cs
new file mode 100644
index 0000000000..a78b7241a4
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/CodeGenerationTests.VerifyKiotaTodoAppClient/TodoApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+using TodoApp.Client.Api;
+namespace TodoApp.Client
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoApiClient : BaseRequestBuilder
+    {
+        /// <summary>The api property</summary>
+        public global::TodoApp.Client.Api.ApiRequestBuilder Api
+        {
+            get => new global::TodoApp.Client.Api.ApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::TodoApp.Client.TodoApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TodoApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..32c694c3e9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e77961fa65
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_0452f380fe4cda4f/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/AnnotationsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/AnnotationsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..73d841b894
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/AnnotationsRequestBuilder.verified.cs
@@ -0,0 +1,77 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AnnotationsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The AsParameters property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder AsParameters
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The fruit property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder Fruit
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndEnum property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder IFromFileAndEnum
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder IFromFileAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromObjectAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder IFromObjectAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The multipleForms property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder MultipleForms
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The singleForm property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder SingleForm
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AnnotationsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AnnotationsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/AsParameters/AsParametersRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/AsParameters/AsParametersRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c314460094
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/AsParameters/AsParametersRequestBuilder.verified.cs
@@ -0,0 +1,117 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\AsParameters
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AsParametersRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AsParametersRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/AsParameters?paramEight={paramEight}&paramFour={paramFour}&paramSix={paramSix}&paramTen={paramTen}&paramTwelve={paramTwelve}&paramTwo={paramTwo}{&paramEleven*,paramFive*,paramNine*,paramOne*,paramSeven*,paramThree*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AsParametersRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/AsParameters?paramEight={paramEight}&paramFour={paramFour}&paramSix={paramSix}&paramTen={paramTen}&paramTwelve={paramTwelve}&paramTwo={paramTwo}{&paramEleven*,paramFive*,paramNine*,paramOne*,paramSeven*,paramThree*}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class AsParametersRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            [QueryParameter("paramEight")]
+            public Time? ParamEight { get; set; }
+            [QueryParameter("paramEleven")]
+            public double? ParamEleven { get; set; }
+            [QueryParameter("paramFive")]
+            public Date? ParamFive { get; set; }
+            [QueryParameter("paramFour")]
+            public DateTimeOffset? ParamFour { get; set; }
+            [QueryParameter("paramNine")]
+            public int? ParamNine { get; set; }
+            /// <summary>Description</summary>
+            [QueryParameter("paramOne")]
+            public Guid? ParamOne { get; set; }
+            [QueryParameter("paramSeven")]
+            public Time? ParamSeven { get; set; }
+            [QueryParameter("paramSix")]
+            public Date? ParamSix { get; set; }
+            [QueryParameter("paramTen")]
+            public int? ParamTen { get; set; }
+            [QueryParameter("paramThree")]
+            public DateTimeOffset? ParamThree { get; set; }
+            [QueryParameter("paramTwelve")]
+            public double? ParamTwelve { get; set; }
+            [QueryParameter("paramTwo")]
+            public Guid? ParamTwo { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class AsParametersRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/Fruit/FruitRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/Fruit/FruitRequestBuilder.verified.cs
new file mode 100644
index 0000000000..1f743a2e89
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/Fruit/FruitRequestBuilder.verified.cs
@@ -0,0 +1,48 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\fruit
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FruitRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.annotations.fruit.item collection</summary>
+        /// <param name="position">The id of the fruit that will be created</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/Fruit/Item/FruitItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/Fruit/Item/FruitItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..2408b0a15d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/Fruit/Item/FruitItemRequestBuilder.verified.cs
@@ -0,0 +1,97 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\fruit\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FruitItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Create a fruit
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit"/></returns>
+        /// <param name="body">Description for Schema</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Create a fruit
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Description for Schema</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class FruitItemRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
new file mode 100644
index 0000000000..72889a4a75
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\IFromFileAndEnum
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndEnumRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndEnum", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndEnum", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndEnumRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..6cf1bf4636
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\IFromFileAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
new file mode 100644
index 0000000000..654ac6720d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
@@ -0,0 +1,67 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class IFromObjectAndStringPostRequestBody : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The tags property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Tags { get; set; }
+#nullable restore
+#else
+        public string Tags { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public IFromObjectAndStringPostRequestBody() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "tags", n => { Tags = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("tags", Tags);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..6fa13e87ac
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\IFromObjectAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromObjectAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromObjectAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromObjectAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromObjectAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/MultipleForms/MultipleFormsPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/MultipleForms/MultipleFormsPostRequestBody.verified.cs
new file mode 100644
index 0000000000..1daf33186d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/MultipleForms/MultipleFormsPostRequestBody.verified.cs
@@ -0,0 +1,115 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class MultipleFormsPostRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The city property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? City { get; set; }
+#nullable restore
+#else
+        public string City { get; set; }
+#endif
+        /// <summary>Description for FirstName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>Description for LastName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>The state property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? State { get; set; }
+#nullable restore
+#else
+        public string State { get; set; }
+#endif
+        /// <summary>Description for Street</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Street { get; set; }
+#nullable restore
+#else
+        public string Street { get; set; }
+#endif
+        /// <summary>The zipCode property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? ZipCode { get; set; }
+#nullable restore
+#else
+        public string ZipCode { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public MultipleFormsPostRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "city", n => { City = n.GetStringValue(); } },
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+                { "state", n => { State = n.GetStringValue(); } },
+                { "street", n => { Street = n.GetStringValue(); } },
+                { "zipCode", n => { ZipCode = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("city", City);
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+            writer.WriteStringValue("state", State);
+            writer.WriteStringValue("street", Street);
+            writer.WriteStringValue("zipCode", ZipCode);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/MultipleForms/MultipleFormsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/MultipleForms/MultipleFormsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..78e5cdc7fc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/MultipleForms/MultipleFormsRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\multipleForms
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class MultipleFormsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/multipleForms", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/multipleForms", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class MultipleFormsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/SingleForm/SingleFormRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/SingleForm/SingleFormRequestBuilder.verified.cs
new file mode 100644
index 0000000000..9f80518ba2
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Annotations/SingleForm/SingleFormRequestBuilder.verified.cs
@@ -0,0 +1,91 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\singleForm
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class SingleFormRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SingleFormRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/singleForm", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SingleFormRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/singleForm", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/x-www-form-urlencoded", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SingleFormRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..1d9f32b2bc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,61 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The annotations property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder Annotations
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The TypeWithTryParse property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder TypeWithTryParse
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The WithOpenApi property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder WithOpenApi
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The XmlComments property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder XmlComments
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/AsParametersRecord.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/AsParametersRecord.verified.cs
new file mode 100644
index 0000000000..b703f26d0a
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/AsParametersRecord.verified.cs
@@ -0,0 +1,94 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class AsParametersRecord : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The paramEight property</summary>
+        public Time? ParamEight { get; set; }
+        /// <summary>The paramEleven property</summary>
+        public double? ParamEleven { get; set; }
+        /// <summary>The paramFive property</summary>
+        public Date? ParamFive { get; set; }
+        /// <summary>The paramFour property</summary>
+        public DateTimeOffset? ParamFour { get; set; }
+        /// <summary>The paramNine property</summary>
+        public int? ParamNine { get; set; }
+        /// <summary>The paramOne property</summary>
+        public Guid? ParamOne { get; set; }
+        /// <summary>The paramSeven property</summary>
+        public Time? ParamSeven { get; set; }
+        /// <summary>The paramSix property</summary>
+        public Date? ParamSix { get; set; }
+        /// <summary>The paramTen property</summary>
+        public int? ParamTen { get; set; }
+        /// <summary>The paramThree property</summary>
+        public DateTimeOffset? ParamThree { get; set; }
+        /// <summary>The paramTwelve property</summary>
+        public double? ParamTwelve { get; set; }
+        /// <summary>The paramTwo property</summary>
+        public Guid? ParamTwo { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "paramEight", n => { ParamEight = n.GetTimeValue(); } },
+                { "paramEleven", n => { ParamEleven = n.GetDoubleValue(); } },
+                { "paramFive", n => { ParamFive = n.GetDateValue(); } },
+                { "paramFour", n => { ParamFour = n.GetDateTimeOffsetValue(); } },
+                { "paramNine", n => { ParamNine = n.GetIntValue(); } },
+                { "paramOne", n => { ParamOne = n.GetGuidValue(); } },
+                { "paramSeven", n => { ParamSeven = n.GetTimeValue(); } },
+                { "paramSix", n => { ParamSix = n.GetDateValue(); } },
+                { "paramTen", n => { ParamTen = n.GetIntValue(); } },
+                { "paramThree", n => { ParamThree = n.GetDateTimeOffsetValue(); } },
+                { "paramTwelve", n => { ParamTwelve = n.GetDoubleValue(); } },
+                { "paramTwo", n => { ParamTwo = n.GetGuidValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteTimeValue("paramEight", ParamEight);
+            writer.WriteDoubleValue("paramEleven", ParamEleven);
+            writer.WriteDateValue("paramFive", ParamFive);
+            writer.WriteDateTimeOffsetValue("paramFour", ParamFour);
+            writer.WriteIntValue("paramNine", ParamNine);
+            writer.WriteGuidValue("paramOne", ParamOne);
+            writer.WriteTimeValue("paramSeven", ParamSeven);
+            writer.WriteDateValue("paramSix", ParamSix);
+            writer.WriteIntValue("paramTen", ParamTen);
+            writer.WriteDateTimeOffsetValue("paramThree", ParamThree);
+            writer.WriteDoubleValue("paramTwelve", ParamTwelve);
+            writer.WriteGuidValue("paramTwo", ParamTwo);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/CurrenciesRate.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/CurrenciesRate.verified.cs
new file mode 100644
index 0000000000..b11e7225fd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/CurrenciesRate.verified.cs
@@ -0,0 +1,69 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class CurrenciesRate : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Currency From</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CurrencyFrom { get; set; }
+#nullable restore
+#else
+        public string CurrencyFrom { get; set; }
+#endif
+        /// <summary>The currencyTo property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CurrencyTo { get; set; }
+#nullable restore
+#else
+        public string CurrencyTo { get; set; }
+#endif
+        /// <summary>The rate property</summary>
+        public double? Rate { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "currencyFrom", n => { CurrencyFrom = n.GetStringValue(); } },
+                { "currencyTo", n => { CurrencyTo = n.GetStringValue(); } },
+                { "rate", n => { Rate = n.GetDoubleValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("currencyFrom", CurrencyFrom);
+            writer.WriteStringValue("currencyTo", CurrencyTo);
+            writer.WriteDoubleValue("rate", Rate);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Fruit.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Fruit.verified.cs
new file mode 100644
index 0000000000..8ce9761fec
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Fruit.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Description for Schema
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class Fruit : IParsable
+    {
+        /// <summary>The name property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Name { get; set; }
+#nullable restore
+#else
+        public string Name { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "name", n => { Name = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("name", Name);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/OrganizationCustomExchangeRatesDto.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/OrganizationCustomExchangeRatesDto.verified.cs
new file mode 100644
index 0000000000..5cd77a470e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/OrganizationCustomExchangeRatesDto.verified.cs
@@ -0,0 +1,58 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class OrganizationCustomExchangeRatesDto : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The currenciesRates property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate>? CurrenciesRates { get; set; }
+#nullable restore
+#else
+        public List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate> CurrenciesRates { get; set; }
+#endif
+        /// <summary>The isUpdated property</summary>
+        public bool? IsUpdated { get; private set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "currenciesRates", n => { CurrenciesRates = n.GetCollectionOfObjectValues<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate>(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate.CreateFromDiscriminatorValue)?.AsList(); } },
+                { "isUpdated", n => { IsUpdated = n.GetBoolValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteCollectionOfObjectValues<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate>("currenciesRates", CurrenciesRates);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Person.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Person.verified.cs
new file mode 100644
index 0000000000..50466e2a4d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Person.verified.cs
@@ -0,0 +1,65 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Person : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The firstName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>The lastName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/PersonAnnotated.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/PersonAnnotated.verified.cs
new file mode 100644
index 0000000000..b21d6a6ae7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/PersonAnnotated.verified.cs
@@ -0,0 +1,65 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class PersonAnnotated : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Description for FirstName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>Description for LastName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Product.verified.cs
new file mode 100644
index 0000000000..77c098a9d5
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/Product.verified.cs
@@ -0,0 +1,63 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents a product
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class Product : ApiException, IParsable
+    {
+        /// <summary>Describes the product</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>Uniquely identifies the product</summary>
+        public int? Id { get; set; }
+        /// <summary>The primary error message.</summary>
+        public override string Message { get => base.Message; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/WeatherForecast.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/WeatherForecast.verified.cs
new file mode 100644
index 0000000000..8dbad82e4f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/Models/WeatherForecast.verified.cs
@@ -0,0 +1,67 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class WeatherForecast : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The date property</summary>
+        public Date? Date { get; set; }
+        /// <summary>The summary property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Summary { get; set; }
+#nullable restore
+#else
+        public string Summary { get; set; }
+#endif
+        /// <summary>The temperatureC property</summary>
+        public int? TemperatureC { get; set; }
+        /// <summary>The temperatureF property</summary>
+        public int? TemperatureF { get; private set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "date", n => { Date = n.GetDateValue(); } },
+                { "summary", n => { Summary = n.GetStringValue(); } },
+                { "temperatureC", n => { TemperatureC = n.GetIntValue(); } },
+                { "temperatureF", n => { TemperatureF = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDateValue("date", Date);
+            writer.WriteStringValue("summary", Summary);
+            writer.WriteIntValue("temperatureC", TemperatureC);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/TypeWithTryParse/Item/WithTryParseItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/TypeWithTryParse/Item/WithTryParseItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..055941e1a7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/TypeWithTryParse/Item/WithTryParseItemRequestBuilder.verified.cs
@@ -0,0 +1,85 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \TypeWithTryParse\{tryParse}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WithTryParseItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithTryParseItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse/{tryParse}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithTryParseItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse/{tryParse}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WithTryParseItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/TypeWithTryParse/TypeWithTryParseRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/TypeWithTryParse/TypeWithTryParseRequestBuilder.verified.cs
new file mode 100644
index 0000000000..a7f8892ecd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/TypeWithTryParse/TypeWithTryParseRequestBuilder.verified.cs
@@ -0,0 +1,48 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \TypeWithTryParse
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TypeWithTryParseRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("tryParse", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TypeWithTryParseRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TypeWithTryParseRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromBody/IFromBodyRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromBody/IFromBodyRequestBuilder.verified.cs
new file mode 100644
index 0000000000..9f5b657944
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromBody/IFromBodyRequestBuilder.verified.cs
@@ -0,0 +1,91 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromBody
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromBodyRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromBodyRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromBody", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromBodyRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromBody", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromBodyRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFile/IFromFileRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFile/IFromFileRequestBuilder.verified.cs
new file mode 100644
index 0000000000..61b5424207
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFile/IFromFileRequestBuilder.verified.cs
@@ -0,0 +1,105 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFile
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFile?queryParameter={queryParameter}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFile?queryParameter={queryParameter}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class IFromFileRequestBuilderPostQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("queryParameter")]
+            public string? QueryParameter { get; set; }
+#nullable restore
+#else
+            [QueryParameter("queryParameter")]
+            public string QueryParameter { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileRequestBuilderPostRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
new file mode 100644
index 0000000000..1500ddcbce
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFileAndEnum
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndEnumRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndEnum", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndEnum", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndEnumRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..106c2340f6
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFileAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileCollection/IFromFileCollectionRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileCollection/IFromFileCollectionRequestBuilder.verified.cs
new file mode 100644
index 0000000000..4afacd0856
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromFileCollection/IFromFileCollectionRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFileCollection
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileCollectionRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileCollectionRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileCollection", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileCollectionRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileCollection", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileCollectionRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
new file mode 100644
index 0000000000..a3c1dcaffc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
@@ -0,0 +1,67 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class IFromObjectAndStringPostRequestBody : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The tags property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Tags { get; set; }
+#nullable restore
+#else
+        public string Tags { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public IFromObjectAndStringPostRequestBody() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "tags", n => { Tags = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("tags", Tags);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..59724371cd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromObjectAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromObjectAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromObjectAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromObjectAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromObjectAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/MultipleForms/MultipleFormsPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/MultipleForms/MultipleFormsPostRequestBody.verified.cs
new file mode 100644
index 0000000000..0b0a90cc76
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/MultipleForms/MultipleFormsPostRequestBody.verified.cs
@@ -0,0 +1,115 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class MultipleFormsPostRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The city property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? City { get; set; }
+#nullable restore
+#else
+        public string City { get; set; }
+#endif
+        /// <summary>The firstName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>The lastName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>The state property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? State { get; set; }
+#nullable restore
+#else
+        public string State { get; set; }
+#endif
+        /// <summary>The street property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Street { get; set; }
+#nullable restore
+#else
+        public string Street { get; set; }
+#endif
+        /// <summary>The zipCode property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? ZipCode { get; set; }
+#nullable restore
+#else
+        public string ZipCode { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public MultipleFormsPostRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "city", n => { City = n.GetStringValue(); } },
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+                { "state", n => { State = n.GetStringValue(); } },
+                { "street", n => { Street = n.GetStringValue(); } },
+                { "zipCode", n => { ZipCode = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("city", City);
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+            writer.WriteStringValue("state", State);
+            writer.WriteStringValue("street", Street);
+            writer.WriteStringValue("zipCode", ZipCode);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/MultipleForms/MultipleFormsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/MultipleForms/MultipleFormsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e6aca56210
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/MultipleForms/MultipleFormsRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\multipleForms
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class MultipleFormsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/multipleForms", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/multipleForms", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class MultipleFormsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/Weatherforecast/WeatherforecastRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/Weatherforecast/WeatherforecastRequestBuilder.verified.cs
new file mode 100644
index 0000000000..94751af1af
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/Weatherforecast/WeatherforecastRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\weatherforecast
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WeatherforecastRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherforecastRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/weatherforecast", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherforecastRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/weatherforecast", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WeatherforecastRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/WithOpenApiRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/WithOpenApiRequestBuilder.verified.cs
new file mode 100644
index 0000000000..ce7b199d2d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/WithOpenApi/WithOpenApiRequestBuilder.verified.cs
@@ -0,0 +1,83 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WithOpenApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The IFromBody property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder IFromBody
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFile property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder IFromFile
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndEnum property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder IFromFileAndEnum
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder IFromFileAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileCollection property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder IFromFileCollection
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromObjectAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder IFromObjectAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The multipleForms property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder MultipleForms
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The weatherforecast property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder Weatherforecast
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithOpenApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithOpenApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/Car/CarRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/Car/CarRequestBuilder.verified.cs
new file mode 100644
index 0000000000..00c5cffc6e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/Car/CarRequestBuilder.verified.cs
@@ -0,0 +1,135 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\Car
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.item collection</summary>
+        /// <param name="position">The product id</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.item collection</summary>
+        /// <param name="position">The product id</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car?Id={Id}{&Description*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car?Id={Id}{&Description*}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarRequestBuilderGetQueryParameters 
+        {
+            /// <summary>Describes the product</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public string? Description { get; set; }
+#nullable restore
+#else
+            public string Description { get; set; }
+#endif
+            /// <summary>Uniquely identifies the product</summary>
+            public int? Id { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/Car/Item/CarItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/Car/Item/CarItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..92c6c82214
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/Car/Item/CarItemRequestBuilder.verified.cs
@@ -0,0 +1,92 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\Car\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/CarWithProduces/CarWithProducesRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/CarWithProduces/CarWithProducesRequestBuilder.verified.cs
new file mode 100644
index 0000000000..377741915d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/CarWithProduces/CarWithProducesRequestBuilder.verified.cs
@@ -0,0 +1,101 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\CarWithProduces
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarWithProducesRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProduces?id={id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProduces?id={id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesRequestBuilderGetQueryParameters 
+        {
+            [QueryParameter("id")]
+            public int? Id { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/CarWithProducesDefaultResponseType/CarWithProducesDefaultResponseTypeRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/CarWithProducesDefaultResponseType/CarWithProducesDefaultResponseTypeRequestBuilder.verified.cs
new file mode 100644
index 0000000000..468b0235ce
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/CarWithProducesDefaultResponseType/CarWithProducesDefaultResponseTypeRequestBuilder.verified.cs
@@ -0,0 +1,106 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\CarWithProducesDefaultResponseType
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarWithProducesDefaultResponseTypeRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesDefaultResponseTypeRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProducesDefaultResponseType?id={id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesDefaultResponseTypeRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProducesDefaultResponseType?id={id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product">When receiving a 4XX or 5XX status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "XXX", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters 
+        {
+            [QueryParameter("id")]
+            public int? Id { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesDefaultResponseTypeRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/XmlCommentsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/XmlCommentsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..4ea49e8371
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_18236050557cb287/XmlComments/XmlCommentsRequestBuilder.verified.cs
@@ -0,0 +1,53 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class XmlCommentsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The Car property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder Car
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The CarWithProduces property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder CarWithProduces
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The CarWithProducesDefaultResponseType property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder CarWithProducesDefaultResponseType
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public XmlCommentsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public XmlCommentsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_1b39b060fe3b17af/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_1b39b060fe3b17af/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..a85db07154
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_1b39b060fe3b17af/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,37 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..fe31ea3785
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,48 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+            if (string.IsNullOrEmpty(RequestAdapter.BaseUrl))
+            {
+                RequestAdapter.BaseUrl = "http://localhost:57556";
+            }
+            PathParameters.TryAdd("baseurl", RequestAdapter.BaseUrl);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e77961fa65
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_290d7bb6a62c35fc/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_2f2aebaf9596b3c5/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_2f2aebaf9596b3c5/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..6a4a90b043
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_2f2aebaf9596b3c5/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,1096 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <param name="body">The resource</param>
+        /// <returns>Created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> OrdersPOSTAsync(string tenantId, Order body)
+        {
+            return OrdersPOSTAsync(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <param name="body">The resource</param>
+        /// <returns>Created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> OrdersPOSTAsync(string tenantId, Order body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/orders"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/orders");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 201)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> OrdersDELETEAsync(string tenantId, System.Collections.Generic.IEnumerable<Order> body)
+        {
+            return OrdersDELETEAsync(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> OrdersDELETEAsync(string tenantId, System.Collections.Generic.IEnumerable<Order> body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/orders"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/orders");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Failed", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <param name="body">deleting Id</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> DeleteByIdAsync(string tenantId, Order body)
+        {
+            return DeleteByIdAsync(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <param name="body">deleting Id</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> DeleteByIdAsync(string tenantId, Order body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/orders/DeleteById"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/orders/DeleteById");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Failed", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> ListAsync(string tenantId, System.Collections.Generic.IEnumerable<Order> body)
+        {
+            return ListAsync(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> ListAsync(string tenantId, System.Collections.Generic.IEnumerable<Order> body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/orders/Delete/List"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/orders/Delete/List");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Failed", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <param name="body">The resource</param>
+        /// <returns>Created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> ProductsPOSTAsync(string tenantId, Product body)
+        {
+            return ProductsPOSTAsync(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <param name="body">The resource</param>
+        /// <returns>Created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> ProductsPOSTAsync(string tenantId, Product body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/products"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 201)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> ProductsDELETEAsync(string tenantId, System.Collections.Generic.IEnumerable<Product> body)
+        {
+            return ProductsDELETEAsync(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> ProductsDELETEAsync(string tenantId, System.Collections.Generic.IEnumerable<Product> body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/products"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Failed", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <param name="body">deleting Id</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> DeleteById2Async(string tenantId, Product body)
+        {
+            return DeleteById2Async(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <param name="body">deleting Id</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> DeleteById2Async(string tenantId, Product body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/products/DeleteById"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/products/DeleteById");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Failed", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> List2Async(string tenantId, System.Collections.Generic.IEnumerable<Product> body)
+        {
+            return List2Async(tenantId, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <param name="body">deleting Ids</param>
+        /// <returns>Deleted</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> List2Async(string tenantId, System.Collections.Generic.IEnumerable<Product> body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tenantId == null)
+                throw new System.ArgumentNullException("tenantId");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "{tenantId}/products/Delete/List"
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tenantId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/products/Delete/List");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Failed", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Order
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("subtotal", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public double Subtotal { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_39927dbb50aae831/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_39927dbb50aae831/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..7c5581de11
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_39927dbb50aae831/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,350 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = "http://localhost:51071";
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync()
+        {
+            return ProductsAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3bdc6e31f7698656/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3bdc6e31f7698656/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..1363660a45
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3bdc6e31f7698656/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,347 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync()
+        {
+            return ProductsAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/Products"
+                    urlBuilder_.Append("api/Products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("foo", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.Collections.Generic.ICollection<System.Collections.Generic.ICollection<int>> Foo { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/ApiRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/ApiRequestBuilder.verified.cs
new file mode 100644
index 0000000000..2de5a7a4af
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/ApiRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The items property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.ItemsRequestBuilder Items
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.ItemsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Find/FindRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Find/FindRequestBuilder.verified.cs
new file mode 100644
index 0000000000..08de162a9c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Find/FindRequestBuilder.verified.cs
@@ -0,0 +1,102 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\find
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FindRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FindRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/find?IsCompleted={IsCompleted}&Text={Text}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FindRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/find?IsCompleted={IsCompleted}&Text={Text}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class FindRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            /// <summary>Gets or sets a value indicating whether to search completed Todo items.</summary>
+            public bool? IsCompleted { get; set; }
+            /// <summary>Gets or sets the text of the filter.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public string? Text { get; set; }
+#nullable restore
+#else
+            public string Text { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class FindRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder.FindRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/GetAfter/GetAfterRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/GetAfter/GetAfterRequestBuilder.verified.cs
new file mode 100644
index 0000000000..9b6c9cf1a7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/GetAfter/GetAfterRequestBuilder.verified.cs
@@ -0,0 +1,94 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\getAfter
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class GetAfterRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetAfterRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/getAfter?value={value}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetAfterRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/getAfter?value={value}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class GetAfterRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            [QueryParameter("value")]
+            public DateTimeOffset? Value { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class GetAfterRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder.GetAfterRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/Complete/CompleteRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/Complete/CompleteRequestBuilder.verified.cs
new file mode 100644
index 0000000000..57899a582d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/Complete/CompleteRequestBuilder.verified.cs
@@ -0,0 +1,98 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}\complete
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CompleteRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete.CompleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CompleteRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/complete", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete.CompleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CompleteRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/complete", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Marks the todo item with the specified ID as complete.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails">When receiving a 400 status code</exception>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PostAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PostAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToPostRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails.CreateFromDiscriminatorValue },
+                { "404", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Marks the todo item with the specified ID as complete.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete.CompleteRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete.CompleteRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete.CompleteRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CompleteRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/ItemsItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/ItemsItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..f9a9422849
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/ItemsItemRequestBuilder.verified.cs
@@ -0,0 +1,158 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ItemsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The complete property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete.CompleteRequestBuilder Complete
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Complete.CompleteRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The priority property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority.PriorityRequestBuilder Priority
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority.PriorityRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Deletes the todo item with the specified ID.
+        /// </summary>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "404", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Gets the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "404", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Deletes the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Gets the todo item with the specified ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ItemsItemRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ItemsItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/Priority/PriorityRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/Priority/PriorityRequestBuilder.verified.cs
new file mode 100644
index 0000000000..86cfb7244a
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/Item/Priority/PriorityRequestBuilder.verified.cs
@@ -0,0 +1,103 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items\{id}\priority
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class PriorityRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority.PriorityRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PriorityRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/priority", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority.PriorityRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PriorityRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items/{id}/priority", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </summary>
+        /// <param name="body">Represents the model for updating the priority of a Todo item.</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails">When receiving a 400 status code</exception>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails">When receiving a 404 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PatchAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PatchAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPatchRequestInformation(body, requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails.CreateFromDiscriminatorValue },
+                { "404", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents the model for updating the priority of a Todo item.</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPatchRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPatchRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.UpdateTodoItemPriorityModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PATCH, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/problem+json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority.PriorityRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority.PriorityRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.Priority.PriorityRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class PriorityRequestBuilderPatchRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/ItemsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/ItemsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..32015ee7db
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Api/Items/ItemsRequestBuilder.verified.cs
@@ -0,0 +1,185 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\items
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ItemsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The find property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder Find
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Find.FindRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The getAfter property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder GetAfter
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.GetAfter.GetAfterRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.api.items.item collection</summary>
+        /// <param name="position">The Todo item&apos;s ID.</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder this[Guid position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.api.items.item collection</summary>
+        /// <param name="position">The Todo item&apos;s ID.</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.Item.ItemsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.ItemsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.ItemsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ItemsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/items", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Gets all of the current user&apos;s todo items.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel"/></returns>
+        /// <param name="body">Represents the model for creating a new Todo item.</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails">When receiving a 400 status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "400", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Gets all of the current user&apos;s todo items.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents the model for creating a new Todo item.</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreateTodoItemModel body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.ItemsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.ItemsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Items.ItemsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ItemsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ItemsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..f1c91cb638
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The api property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder Api
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/CreateTodoItemModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/CreateTodoItemModel.verified.cs
new file mode 100644
index 0000000000..c06131f459
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/CreateTodoItemModel.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents the model for creating a new Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CreateTodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the text of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Text { get; set; }
+#nullable restore
+#else
+        public string Text { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreateTodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreateTodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreateTodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "text", n => { Text = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("text", Text);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/CreatedTodoItemModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/CreatedTodoItemModel.verified.cs
new file mode 100644
index 0000000000..f3bd86efe7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/CreatedTodoItemModel.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents the model for a created Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CreatedTodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the ID of the created Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Id { get; set; }
+#nullable restore
+#else
+        public string Id { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreatedTodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "id", n => { Id = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/ProblemDetails.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/ProblemDetails.verified.cs
new file mode 100644
index 0000000000..b2ca46048c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/ProblemDetails.verified.cs
@@ -0,0 +1,102 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class ProblemDetails : ApiException, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The detail property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Detail { get; set; }
+#nullable restore
+#else
+        public string Detail { get; set; }
+#endif
+        /// <summary>The instance property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Instance { get; set; }
+#nullable restore
+#else
+        public string Instance { get; set; }
+#endif
+        /// <summary>The primary error message.</summary>
+        public override string Message { get => base.Message; }
+        /// <summary>The status property</summary>
+        public int? Status { get; set; }
+        /// <summary>The title property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Title { get; set; }
+#nullable restore
+#else
+        public string Title { get; set; }
+#endif
+        /// <summary>The type property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Type { get; set; }
+#nullable restore
+#else
+        public string Type { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails"/> and sets the default values.
+        /// </summary>
+        public ProblemDetails()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.ProblemDetails();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "detail", n => { Detail = n.GetStringValue(); } },
+                { "instance", n => { Instance = n.GetStringValue(); } },
+                { "status", n => { Status = n.GetIntValue(); } },
+                { "title", n => { Title = n.GetStringValue(); } },
+                { "type", n => { Type = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("detail", Detail);
+            writer.WriteStringValue("instance", Instance);
+            writer.WriteIntValue("status", Status);
+            writer.WriteStringValue("title", Title);
+            writer.WriteStringValue("type", Type);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoItemModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoItemModel.verified.cs
new file mode 100644
index 0000000000..9ecbe5a36e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoItemModel.verified.cs
@@ -0,0 +1,82 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents a Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoItemModel : IParsable
+    {
+        /// <summary>Gets or sets the date and time the item was completed.</summary>
+        public DateTimeOffset? CompletedAt { get; set; }
+        /// <summary>Gets or sets the date and time the item was created.</summary>
+        public DateTimeOffset? CreatedAt { get; set; }
+        /// <summary>Gets or sets the ID of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Id { get; set; }
+#nullable restore
+#else
+        public string Id { get; set; }
+#endif
+        /// <summary>Gets or sets the date and time the Todo item was last updated.</summary>
+        public DateTimeOffset? LastUpdated { get; set; }
+        /// <summary>Gets or sets the optional priority of the Todo item.</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoPriority? Priority { get; set; }
+        /// <summary>Gets or sets the text of the Todo item.</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Text { get; set; }
+#nullable restore
+#else
+        public string Text { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "completedAt", n => { CompletedAt = n.GetDateTimeOffsetValue(); } },
+                { "createdAt", n => { CreatedAt = n.GetDateTimeOffsetValue(); } },
+                { "id", n => { Id = n.GetStringValue(); } },
+                { "lastUpdated", n => { LastUpdated = n.GetDateTimeOffsetValue(); } },
+                { "priority", n => { Priority = n.GetEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoPriority>(); } },
+                { "text", n => { Text = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDateTimeOffsetValue("completedAt", CompletedAt);
+            writer.WriteDateTimeOffsetValue("createdAt", CreatedAt);
+            writer.WriteStringValue("id", Id);
+            writer.WriteDateTimeOffsetValue("lastUpdated", LastUpdated);
+            writer.WriteEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoPriority>("priority", Priority);
+            writer.WriteStringValue("text", Text);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoListViewModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoListViewModel.verified.cs
new file mode 100644
index 0000000000..36f26f3a29
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoListViewModel.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents a collection of Todo items.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodoListViewModel : IParsable
+    {
+        /// <summary>Gets or sets the Todo item(s).</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel>? Items { get; set; }
+#nullable restore
+#else
+        public List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel> Items { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoListViewModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "items", n => { Items = n.GetCollectionOfObjectValues<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel>(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel.CreateFromDiscriminatorValue)?.AsList(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteCollectionOfObjectValues<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoItemModel>("items", Items);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoPriority.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoPriority.verified.cs
new file mode 100644
index 0000000000..edd12d14fe
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/TodoPriority.verified.cs
@@ -0,0 +1,23 @@
+// <auto-generated/>
+using System.Runtime.Serialization;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>The priority levels for a Todo item.</summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public enum TodoPriority
+    {
+        [EnumMember(Value = "Normal")]
+        #pragma warning disable CS1591
+        Normal,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "Low")]
+        #pragma warning disable CS1591
+        Low,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "High")]
+        #pragma warning disable CS1591
+        High,
+        #pragma warning restore CS1591
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/UpdateTodoItemPriorityModel.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/UpdateTodoItemPriorityModel.verified.cs
new file mode 100644
index 0000000000..c89cca25c2
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_3cdd085efa40fddd/Models/UpdateTodoItemPriorityModel.verified.cs
@@ -0,0 +1,50 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents the model for updating the priority of a Todo item.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class UpdateTodoItemPriorityModel : IParsable
+    {
+        /// <summary>Gets or sets the new priority of the Todo item.</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoPriority? Priority { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.UpdateTodoItemPriorityModel"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.UpdateTodoItemPriorityModel CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.UpdateTodoItemPriorityModel();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "priority", n => { Priority = n.GetEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoPriority>(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TodoPriority>("priority", Priority);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..32c694c3e9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/Item/ProductsItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/Item/ProductsItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..2cbb808790
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/Item/ProductsItemRequestBuilder.verified.cs
@@ -0,0 +1,213 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/{id}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PatchAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PatchAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPatchRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PutAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PutAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPutRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/octet-stream");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPatchRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPatchRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PATCH, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/octet-stream");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPutRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPutRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PUT, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/octet-stream");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderPatchRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderPutRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/Item/ProductsPatchRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/Item/ProductsPatchRequestBody.verified.cs
new file mode 100644
index 0000000000..aa13c65c65
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/Item/ProductsPatchRequestBody.verified.cs
@@ -0,0 +1,55 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class ProductsPatchRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody"/> and sets the default values.
+        /// </summary>
+        public ProductsPatchRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..b68de75cb8
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_484a86c0761779e7/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,157 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.products.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.products.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Api/ApiRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Api/ApiRequestBuilder.verified.cs
new file mode 100644
index 0000000000..a14dd539ca
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Api/ApiRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The Products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Api/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Api/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..5210c94755
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Api/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\Products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/Products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/Products", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..f1c91cb638
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The api property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder Api
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Models/Product.verified.cs
new file mode 100644
index 0000000000..172a72b305
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_4dd7802f98d99c89/Models/Product.verified.cs
@@ -0,0 +1,55 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The foo property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public UntypedNode? Foo { get; set; }
+#nullable restore
+#else
+        public UntypedNode Foo { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "foo", n => { Foo = n.GetObjectValue<UntypedNode>(UntypedNode.CreateFromDiscriminatorValue); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteObjectValue<UntypedNode>("foo", Foo);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..32c694c3e9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e77961fa65
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_565c8d3b8ad0210d/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/Delete/DeleteRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/Delete/DeleteRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c89eca1a89
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/Delete/DeleteRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\orders\Delete
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class DeleteRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The List property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List.ListRequestBuilder List
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List.ListRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.DeleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders/Delete", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.DeleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders/Delete", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/Delete/List/ListRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/Delete/List/ListRequestBuilder.verified.cs
new file mode 100644
index 0000000000..3b404f70c9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/Delete/List/ListRequestBuilder.verified.cs
@@ -0,0 +1,97 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\orders\Delete\List
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ListRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List.ListRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ListRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders/Delete/List", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List.ListRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ListRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders/Delete/List", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToDeleteRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List.ListRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List.ListRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.List.ListRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ListRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/DeleteById/DeleteByIdRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/DeleteById/DeleteByIdRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c1f48f28e7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/DeleteById/DeleteByIdRequestBuilder.verified.cs
@@ -0,0 +1,97 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\orders\DeleteById
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class DeleteByIdRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById.DeleteByIdRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteByIdRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders/DeleteById", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById.DeleteByIdRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteByIdRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders/DeleteById", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> DeleteAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> DeleteAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToDeleteRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById.DeleteByIdRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById.DeleteByIdRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById.DeleteByIdRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class DeleteByIdRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/OrdersRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/OrdersRequestBuilder.verified.cs
new file mode 100644
index 0000000000..95389db696
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Orders/OrdersRequestBuilder.verified.cs
@@ -0,0 +1,159 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\orders
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class OrdersRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The DeleteById property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById.DeleteByIdRequestBuilder DeleteById
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.DeleteById.DeleteByIdRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The DeletePath property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.DeleteRequestBuilder DeletePath
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.Delete.DeleteRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.OrdersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public OrdersRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.OrdersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public OrdersRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/orders", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToDeleteRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.OrdersRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.OrdersRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.OrdersRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class OrdersRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class OrdersRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/Delete/DeleteRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/Delete/DeleteRequestBuilder.verified.cs
new file mode 100644
index 0000000000..7f6b5112c4
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/Delete/DeleteRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\products\Delete
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class DeleteRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The List property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List.ListRequestBuilder List
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List.ListRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.DeleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products/Delete", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.DeleteRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products/Delete", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/Delete/List/ListRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/Delete/List/ListRequestBuilder.verified.cs
new file mode 100644
index 0000000000..b4b80f7286
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/Delete/List/ListRequestBuilder.verified.cs
@@ -0,0 +1,97 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\products\Delete\List
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ListRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List.ListRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ListRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products/Delete/List", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List.ListRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ListRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products/Delete/List", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToDeleteRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Delete by Id List
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List.ListRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List.ListRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.List.ListRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ListRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/DeleteById/DeleteByIdRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/DeleteById/DeleteByIdRequestBuilder.verified.cs
new file mode 100644
index 0000000000..956efdade1
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/DeleteById/DeleteByIdRequestBuilder.verified.cs
@@ -0,0 +1,97 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\products\DeleteById
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class DeleteByIdRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById.DeleteByIdRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteByIdRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products/DeleteById", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById.DeleteByIdRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DeleteByIdRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products/DeleteById", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> DeleteAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> DeleteAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToDeleteRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Delete by Id
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById.DeleteByIdRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById.DeleteByIdRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById.DeleteByIdRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class DeleteByIdRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..fe7f74c702
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,159 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}\products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The DeleteById property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById.DeleteByIdRequestBuilder DeleteById
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.DeleteById.DeleteByIdRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The DeletePath property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.DeleteRequestBuilder DeletePath
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.Delete.DeleteRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}/products", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> DeleteAsync(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToDeleteRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Delete by Ids
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Creates a resource
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/WithTenantItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/WithTenantItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c66623e61f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Item/WithTenantItemRequestBuilder.verified.cs
@@ -0,0 +1,47 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \{tenantId}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WithTenantItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The orders property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.OrdersRequestBuilder Orders
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Orders.OrdersRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.WithTenantItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithTenantItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.WithTenantItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithTenantItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/{tenantId}", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..aea852567b
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,50 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.WithTenantItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.WithTenantItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("tenantId", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Item.WithTenantItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Models/Order.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Models/Order.verified.cs
new file mode 100644
index 0000000000..b159b1421c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Models/Order.verified.cs
@@ -0,0 +1,53 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Order : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>The subtotal property</summary>
+        public double? Subtotal { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Order();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "id", n => { Id = n.GetIntValue(); } },
+                { "subtotal", n => { Subtotal = n.GetDoubleValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteIntValue("id", Id);
+            writer.WriteDoubleValue("subtotal", Subtotal);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_5c64fb6b50e962ed/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..52c5f219ab
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,48 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+            if (string.IsNullOrEmpty(RequestAdapter.BaseUrl))
+            {
+                RequestAdapter.BaseUrl = "http://localhost:51071";
+            }
+            PathParameters.TryAdd("baseurl", RequestAdapter.BaseUrl);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e77961fa65
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6010233cf877b681/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..8aac6f0d16
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The WeatherForecast property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast.WeatherForecastRequestBuilder WeatherForecast
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast.WeatherForecastRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/Models/WeatherForecast.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/Models/WeatherForecast.verified.cs
new file mode 100644
index 0000000000..48fc15286c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/Models/WeatherForecast.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class WeatherForecast : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The date property</summary>
+        public DateTimeOffset? Date { get; set; }
+        /// <summary>The summary property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Summary { get; set; }
+#nullable restore
+#else
+        public string Summary { get; set; }
+#endif
+        /// <summary>The temperatureC property</summary>
+        public int? TemperatureC { get; set; }
+        /// <summary>The temperatureF property</summary>
+        public int? TemperatureF { get; private set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "date", n => { Date = n.GetDateTimeOffsetValue(); } },
+                { "summary", n => { Summary = n.GetStringValue(); } },
+                { "temperatureC", n => { TemperatureC = n.GetIntValue(); } },
+                { "temperatureF", n => { TemperatureF = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDateTimeOffsetValue("date", Date);
+            writer.WriteStringValue("summary", Summary);
+            writer.WriteIntValue("temperatureC", TemperatureC);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/WeatherForecast/WeatherForecastRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/WeatherForecast/WeatherForecastRequestBuilder.verified.cs
new file mode 100644
index 0000000000..433c7dfddd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6f5bddaf4a3479f0/WeatherForecast/WeatherForecastRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WeatherForecast
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WeatherForecastRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast.WeatherForecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherForecastRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WeatherForecast", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast.WeatherForecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherForecastRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WeatherForecast", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast.WeatherForecastRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast.WeatherForecastRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WeatherForecast.WeatherForecastRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WeatherForecastRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..4c2aae0b7f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The todos property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.TodosRequestBuilder Todos
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.TodosRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Models/Todo.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Models/Todo.verified.cs
new file mode 100644
index 0000000000..58ca8f6360
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Models/Todo.verified.cs
@@ -0,0 +1,68 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Todo : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The dueBy property</summary>
+        public Date? DueBy { get; set; }
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>The isComplete property</summary>
+        public bool? IsComplete { get; set; }
+        /// <summary>The title property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Title { get; set; }
+#nullable restore
+#else
+        public string Title { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "dueBy", n => { DueBy = n.GetDateValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+                { "isComplete", n => { IsComplete = n.GetBoolValue(); } },
+                { "title", n => { Title = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDateValue("dueBy", DueBy);
+            writer.WriteIntValue("id", Id);
+            writer.WriteBoolValue("isComplete", IsComplete);
+            writer.WriteStringValue("title", Title);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Todos/Item/TodosItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Todos/Item/TodosItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..06b25cedc9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Todos/Item/TodosItemRequestBuilder.verified.cs
@@ -0,0 +1,84 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \todos\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodosItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TodosItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/todos/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TodosItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/todos/{id}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class TodosItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Todos/TodosRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Todos/TodosRequestBuilder.verified.cs
new file mode 100644
index 0000000000..f68a92feb8
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_6fe5d13a9d93e91a/Todos/TodosRequestBuilder.verified.cs
@@ -0,0 +1,113 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \todos
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TodosRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.todos.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.todos.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.Item.TodosItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.TodosRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TodosRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/todos", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.TodosRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TodosRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/todos", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Todo.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.TodosRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.TodosRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Todos.TodosRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class TodosRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..e035d3baf7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,48 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+            if (string.IsNullOrEmpty(RequestAdapter.BaseUrl))
+            {
+                RequestAdapter.BaseUrl = "/resource-server";
+            }
+            PathParameters.TryAdd("baseurl", RequestAdapter.BaseUrl);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Models/Product.verified.cs
new file mode 100644
index 0000000000..c2d9b9ae70
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Models/Product.verified.cs
@@ -0,0 +1,62 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The id property</summary>
+        public int? Id { get; private set; }
+        /// <summary>The serialNo property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? SerialNo { get; set; }
+#nullable restore
+#else
+        public string SerialNo { get; set; }
+#endif
+        /// <summary>The status property</summary>
+        public int? Status { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "id", n => { Id = n.GetIntValue(); } },
+                { "serialNo", n => { SerialNo = n.GetStringValue(); } },
+                { "status", n => { Status = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("serialNo", SerialNo);
+            writer.WriteIntValue("status", Status);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Products/Item/ProductsItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Products/Item/ProductsItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..0606ff62b0
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Products/Item/ProductsItemRequestBuilder.verified.cs
@@ -0,0 +1,124 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/{id}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json, text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..d6264fa087
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_768e677c94277084/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,156 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.products.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.products.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78402e8ccf6874be/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78402e8ccf6874be/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..25719b19df
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78402e8ccf6874be/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,356 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<WeatherForecast>> WeatherForecastAsync()
+        {
+            return WeatherForecastAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<WeatherForecast>> WeatherForecastAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WeatherForecast"
+                    urlBuilder_.Append("WeatherForecast");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<WeatherForecast>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class WeatherForecast
+    {
+
+        [Newtonsoft.Json.JsonProperty("date", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset Date { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("temperatureC", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int TemperatureC { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("temperatureF", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int TemperatureF { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("summary", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Summary { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/ApiRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/ApiRequestBuilder.verified.cs
new file mode 100644
index 0000000000..b9cfc5cc8e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/ApiRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The users property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersRequestBuilder Users
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/Users/UsersPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/Users/UsersPostRequestBody.verified.cs
new file mode 100644
index 0000000000..a730fce457
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/Users/UsersPostRequestBody.verified.cs
@@ -0,0 +1,75 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class UsersPostRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The email property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Email { get; set; }
+#nullable restore
+#else
+        public string Email { get; set; }
+#endif
+        /// <summary>The password property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Password { get; set; }
+#nullable restore
+#else
+        public string Password { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public UsersPostRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "email", n => { Email = n.GetStringValue(); } },
+                { "password", n => { Password = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("email", Email);
+            writer.WriteStringValue("password", Password);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/Users/UsersRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/Users/UsersRequestBuilder.verified.cs
new file mode 100644
index 0000000000..7787eb6786
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/Api/Users/UsersRequestBuilder.verified.cs
@@ -0,0 +1,88 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\users
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class UsersRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public UsersRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/users", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public UsersRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/users", rawUrl)
+        {
+        }
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            await RequestAdapter.SendNoContentAsync(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.Users.UsersRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class UsersRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..f1c91cb638
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_78fcf947cfcdf156/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The api property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder Api
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_887704eaa79e8ac0/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_887704eaa79e8ac0/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..a4ff686c47
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_887704eaa79e8ac0/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,49 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    
+
+    
+
+
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..c672df5e27
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The Products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..7e8b4a875f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9267f2f0046c723d/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,102 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \Products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Products?api-version={api%2Dversion}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Products?api-version={api%2Dversion}", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ProductsRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("api%2Dversion")]
+            public string? ApiVersion { get; set; }
+#nullable restore
+#else
+            [QueryParameter("api%2Dversion")]
+            public string ApiVersion { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9b761e4794fc013c/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9b761e4794fc013c/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..1ad2c9ba51
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9b761e4794fc013c/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,832 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task AnimalsAsync(Animal body)
+        {
+            return AnimalsAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task AnimalsAsync(Animal body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "Animals"
+                    urlBuilder_.Append("Animals");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> SecondLevelAsync(SubSubType body)
+        {
+            return SecondLevelAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> SecondLevelAsync(SubSubType body, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "SecondLevel"
+                    urlBuilder_.Append("SecondLevel");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task SystemTextJsonAnimalsAsync(SystemTextJsonAnimal body)
+        {
+            return SystemTextJsonAnimalsAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task SystemTextJsonAnimalsAsync(SystemTextJsonAnimal body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "SystemTextJsonAnimals"
+                    urlBuilder_.Append("SystemTextJsonAnimals");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task SystemTextJsonDefaultDiscriminatorAnimalsAsync(SystemTextJsonDefaultDiscriminatorAnimal body)
+        {
+            return SystemTextJsonDefaultDiscriminatorAnimalsAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task SystemTextJsonDefaultDiscriminatorAnimalsAsync(SystemTextJsonDefaultDiscriminatorAnimal body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "SystemTextJsonDefaultDiscriminatorAnimals"
+                    urlBuilder_.Append("SystemTextJsonDefaultDiscriminatorAnimals");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [Newtonsoft.Json.JsonConverter(typeof(JsonInheritanceConverter), "animalType")]
+    [JsonInheritanceAttribute("Cat", typeof(Cat))]
+    [JsonInheritanceAttribute("Dog", typeof(Dog))]
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Animal
+    {
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public enum AnimalType
+    {
+
+        [System.Runtime.Serialization.EnumMember(Value = @"Cat")]
+        Cat = 0,
+
+        [System.Runtime.Serialization.EnumMember(Value = @"Dog")]
+        Dog = 1,
+
+    }
+
+    [Newtonsoft.Json.JsonConverter(typeof(JsonInheritanceConverter), "discriminator")]
+    [JsonInheritanceAttribute("SubSubType", typeof(SubSubType))]
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class BaseType
+    {
+
+        [Newtonsoft.Json.JsonProperty("property", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Property { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Cat : Animal
+    {
+
+        [Newtonsoft.Json.JsonProperty("catSpecificProperty", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string CatSpecificProperty { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Dog : Animal
+    {
+
+        [Newtonsoft.Json.JsonProperty("dogSpecificProperty", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string DogSpecificProperty { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class SubSubType : BaseType
+    {
+
+        [Newtonsoft.Json.JsonProperty("property2", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Property2 { get; set; }
+
+    }
+
+    [Newtonsoft.Json.JsonConverter(typeof(JsonInheritanceConverter), "animalType")]
+    [JsonInheritanceAttribute("Cat", typeof(SystemTextJsonCat))]
+    [JsonInheritanceAttribute("Dog", typeof(SystemTextJsonDog))]
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class SystemTextJsonAnimal
+    {
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class SystemTextJsonCat : SystemTextJsonAnimal
+    {
+
+        [Newtonsoft.Json.JsonProperty("catSpecificProperty", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string CatSpecificProperty { get; set; }
+
+    }
+
+    [Newtonsoft.Json.JsonConverter(typeof(JsonInheritanceConverter), "$type")]
+    [JsonInheritanceAttribute("Cat", typeof(SystemTextJsonDefaultDiscriminatorCat))]
+    [JsonInheritanceAttribute("Dog", typeof(SystemTextJsonDefaultDiscriminatorDog))]
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class SystemTextJsonDefaultDiscriminatorAnimal
+    {
+
+        [Newtonsoft.Json.JsonProperty("animalType", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string AnimalType { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class SystemTextJsonDefaultDiscriminatorCat : SystemTextJsonDefaultDiscriminatorAnimal
+    {
+
+        [Newtonsoft.Json.JsonProperty("catSpecificProperty", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string CatSpecificProperty { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class SystemTextJsonDefaultDiscriminatorDog : SystemTextJsonDefaultDiscriminatorAnimal
+    {
+
+        [Newtonsoft.Json.JsonProperty("dogSpecificProperty", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string DogSpecificProperty { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class SystemTextJsonDog : SystemTextJsonAnimal
+    {
+
+        [Newtonsoft.Json.JsonProperty("dogSpecificProperty", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string DogSpecificProperty { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    [System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple = true)]
+    internal class JsonInheritanceAttribute : System.Attribute
+    {
+        public JsonInheritanceAttribute(string key, System.Type type)
+        {
+            Key = key;
+            Type = type;
+        }
+
+        public string Key { get; }
+
+        public System.Type Type { get; }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public class JsonInheritanceConverter : Newtonsoft.Json.JsonConverter
+    {
+        internal static readonly string DefaultDiscriminatorName = "discriminator";
+
+        private readonly string _discriminatorName;
+
+        [System.ThreadStatic]
+        private static bool _isReading;
+
+        [System.ThreadStatic]
+        private static bool _isWriting;
+
+        public JsonInheritanceConverter()
+        {
+            _discriminatorName = DefaultDiscriminatorName;
+        }
+
+        public JsonInheritanceConverter(string discriminatorName)
+        {
+            _discriminatorName = discriminatorName;
+        }
+
+        public string DiscriminatorName { get { return _discriminatorName; } }
+
+        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
+        {
+            try
+            {
+                _isWriting = true;
+
+                var jObject = Newtonsoft.Json.Linq.JObject.FromObject(value, serializer);
+                jObject.AddFirst(new Newtonsoft.Json.Linq.JProperty(_discriminatorName, GetSubtypeDiscriminator(value.GetType())));
+                writer.WriteToken(jObject.CreateReader());
+            }
+            finally
+            {
+                _isWriting = false;
+            }
+        }
+
+        public override bool CanWrite
+        {
+            get
+            {
+                if (_isWriting)
+                {
+                    _isWriting = false;
+                    return false;
+                }
+                return true;
+            }
+        }
+
+        public override bool CanRead
+        {
+            get
+            {
+                if (_isReading)
+                {
+                    _isReading = false;
+                    return false;
+                }
+                return true;
+            }
+        }
+
+        public override bool CanConvert(System.Type objectType)
+        {
+            return true;
+        }
+
+        public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
+        {
+            var jObject = serializer.Deserialize<Newtonsoft.Json.Linq.JObject>(reader);
+            if (jObject == null)
+                return null;
+
+            var discriminatorValue = jObject.GetValue(_discriminatorName);
+            var discriminator = discriminatorValue != null ? Newtonsoft.Json.Linq.Extensions.Value<string>(discriminatorValue) : null;
+            var subtype = GetObjectSubtype(objectType, discriminator);
+
+            var objectContract = serializer.ContractResolver.ResolveContract(subtype) as Newtonsoft.Json.Serialization.JsonObjectContract;
+            if (objectContract == null || System.Linq.Enumerable.All(objectContract.Properties, p => p.PropertyName != _discriminatorName))
+            {
+                jObject.Remove(_discriminatorName);
+            }
+
+            try
+            {
+                _isReading = true;
+                return serializer.Deserialize(jObject.CreateReader(), subtype);
+            }
+            finally
+            {
+                _isReading = false;
+            }
+        }
+
+        private System.Type GetObjectSubtype(System.Type objectType, string discriminator)
+        {
+            foreach (var attribute in System.Reflection.CustomAttributeExtensions.GetCustomAttributes<JsonInheritanceAttribute>(System.Reflection.IntrospectionExtensions.GetTypeInfo(objectType), true))
+            {
+                if (attribute.Key == discriminator)
+                    return attribute.Type;
+            }
+
+            return objectType;
+        }
+
+        private string GetSubtypeDiscriminator(System.Type objectType)
+        {
+            foreach (var attribute in System.Reflection.CustomAttributeExtensions.GetCustomAttributes<JsonInheritanceAttribute>(System.Reflection.IntrospectionExtensions.GetTypeInfo(objectType), true))
+            {
+                if (attribute.Type == objectType)
+                    return attribute.Key;
+            }
+
+            return objectType.Name;
+        }
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9ff8910c4c525cf0/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9ff8910c4c525cf0/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..49b8b9ccc3
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_9ff8910c4c525cf0/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,356 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync(string api_version)
+        {
+            return ProductsAsync(api_version, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync(string api_version, System.Threading.CancellationToken cancellationToken)
+        {
+            if (api_version == null)
+                throw new System.ArgumentNullException("api_version");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "Products"
+                    urlBuilder_.Append("Products");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("api-version")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(api_version, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a183add29706ff70/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a183add29706ff70/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..25296f73c5
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a183add29706ff70/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,350 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync()
+        {
+            return ProductsAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a1ab8f6c5e8ef470/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a1ab8f6c5e8ef470/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..5cecb9b037
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a1ab8f6c5e8ef470/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,618 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> ProductsPOSTAsync(string api_version, Product body)
+        {
+            return ProductsPOSTAsync(api_version, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> ProductsPOSTAsync(string api_version, Product body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (api_version == null)
+                throw new System.ArgumentNullException("api_version");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "Products"
+                    urlBuilder_.Append("Products");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("api-version")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(api_version, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAllAsync(string api_version)
+        {
+            return ProductsAllAsync(api_version, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAllAsync(string api_version, System.Threading.CancellationToken cancellationToken)
+        {
+            if (api_version == null)
+                throw new System.ArgumentNullException("api_version");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "Products"
+                    urlBuilder_.Append("Products");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("api-version")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(api_version, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task ProductsPUTAsync(int id, string api_version, Product body)
+        {
+            return ProductsPUTAsync(id, api_version, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task ProductsPUTAsync(int id, string api_version, Product body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            if (api_version == null)
+                throw new System.ArgumentNullException("api_version");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("PUT");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "Products/{id}"
+                    urlBuilder_.Append("Products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("api-version")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(api_version, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task ProductsDELETEAsync(int id, string api_version)
+        {
+            return ProductsDELETEAsync(id, api_version, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task ProductsDELETEAsync(int id, string api_version, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            if (api_version == null)
+                throw new System.ArgumentNullException("api_version");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "Products/{id}"
+                    urlBuilder_.Append("Products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("api-version")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(api_version, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a4dcbaf37de46e5e/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a4dcbaf37de46e5e/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..25a5554d9c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_a4dcbaf37de46e5e/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,1224 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <summary>
+        /// Get all Todo items
+        /// </summary>
+        /// <remarks>
+        /// Gets all of the current user's todo items.
+        /// </remarks>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<TodoListViewModel> ListTodosAsync()
+        {
+            return ListTodosAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Get all Todo items
+        /// </summary>
+        /// <remarks>
+        /// Gets all of the current user's todo items.
+        /// </remarks>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<TodoListViewModel> ListTodosAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items"
+                    urlBuilder_.Append("api/items");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<TodoListViewModel>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Create a new Todo item
+        /// </summary>
+        /// <remarks>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </remarks>
+        /// <returns>Created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<CreatedTodoItemModel> CreateTodoAsync(CreateTodoItemModel body)
+        {
+            return CreateTodoAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Create a new Todo item
+        /// </summary>
+        /// <remarks>
+        /// Creates a new todo item for the current user and returns its ID.
+        /// </remarks>
+        /// <returns>Created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<CreatedTodoItemModel> CreateTodoAsync(CreateTodoItemModel body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items"
+                    urlBuilder_.Append("api/items");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 201)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<CreatedTodoItemModel>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 400)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<ProblemDetails>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<ProblemDetails>("Bad Request", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Get a specific Todo item
+        /// </summary>
+        /// <remarks>
+        /// Gets the todo item with the specified ID.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<TodoItemModel> GetTodoAsync(System.Guid id)
+        {
+            return GetTodoAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Get a specific Todo item
+        /// </summary>
+        /// <remarks>
+        /// Gets the todo item with the specified ID.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<TodoItemModel> GetTodoAsync(System.Guid id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items/{id}"
+                    urlBuilder_.Append("api/items/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<TodoItemModel>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<ProblemDetails>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<ProblemDetails>("Not Found", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Delete a Todo item
+        /// </summary>
+        /// <remarks>
+        /// Deletes the todo item with the specified ID.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>No Content</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task DeleteTodoAsync(System.Guid id)
+        {
+            return DeleteTodoAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Delete a Todo item
+        /// </summary>
+        /// <remarks>
+        /// Deletes the todo item with the specified ID.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>No Content</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task DeleteTodoAsync(System.Guid id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items/{id}"
+                    urlBuilder_.Append("api/items/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 204)
+                        {
+                            return;
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<ProblemDetails>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<ProblemDetails>("Not Found", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Mark a Todo item as completed
+        /// </summary>
+        /// <remarks>
+        /// Marks the todo item with the specified ID as complete.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>No Content</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task CompleteTodoAsync(System.Guid id)
+        {
+            return CompleteTodoAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Mark a Todo item as completed
+        /// </summary>
+        /// <remarks>
+        /// Marks the todo item with the specified ID as complete.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>No Content</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task CompleteTodoAsync(System.Guid id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Content = new System.Net.Http.StringContent(string.Empty, System.Text.Encoding.UTF8, "application/json");
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items/{id}/complete"
+                    urlBuilder_.Append("api/items/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/complete");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 204)
+                        {
+                            return;
+                        }
+                        else
+                        if (status_ == 400)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<ProblemDetails>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<ProblemDetails>("Bad Request", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<ProblemDetails>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<ProblemDetails>("Not Found", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Updates the priority of a Todo item
+        /// </summary>
+        /// <remarks>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>No Content</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task UpdateTodoPriorityAsync(System.Guid id, UpdateTodoItemPriorityModel body)
+        {
+            return UpdateTodoPriorityAsync(id, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Updates the priority of a Todo item
+        /// </summary>
+        /// <remarks>
+        /// Updates the priority of the todo item with the specified ID to the specified priority.
+        /// </remarks>
+        /// <param name="id">The Todo item's ID.</param>
+        /// <returns>No Content</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task UpdateTodoPriorityAsync(System.Guid id, UpdateTodoItemPriorityModel body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("PATCH");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items/{id}/priority"
+                    urlBuilder_.Append("api/items/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/priority");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 204)
+                        {
+                            return;
+                        }
+                        else
+                        if (status_ == 400)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<ProblemDetails>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<ProblemDetails>("Bad Request", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                        else
+                        if (status_ == 404)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<ProblemDetails>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<ProblemDetails>("Not Found", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="text">Gets or sets the text of the filter.</param>
+        /// <param name="isCompleted">Gets or sets a value indicating whether to search completed Todo items.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<TodoListViewModel> FindTodoAsync(string text, bool isCompleted)
+        {
+            return FindTodoAsync(text, isCompleted, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="text">Gets or sets the text of the filter.</param>
+        /// <param name="isCompleted">Gets or sets a value indicating whether to search completed Todo items.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<TodoListViewModel> FindTodoAsync(string text, bool isCompleted, System.Threading.CancellationToken cancellationToken)
+        {
+            if (text == null)
+                throw new System.ArgumentNullException("text");
+
+            if (isCompleted == null)
+                throw new System.ArgumentNullException("isCompleted");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items/find"
+                    urlBuilder_.Append("api/items/find");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("Text")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(text, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("IsCompleted")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(isCompleted, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<TodoListViewModel>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<TodoListViewModel> GetAfterDateAsync(System.DateTimeOffset value)
+        {
+            return GetAfterDateAsync(value, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<TodoListViewModel> GetAfterDateAsync(System.DateTimeOffset value, System.Threading.CancellationToken cancellationToken)
+        {
+            if (value == null)
+                throw new System.ArgumentNullException("value");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/items/getAfter"
+                    urlBuilder_.Append("api/items/getAfter");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("value")).Append('=').Append(System.Uri.EscapeDataString(value.ToString("s", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<TodoListViewModel>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    /// <summary>
+    /// Represents the model for creating a new Todo item.
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class CreateTodoItemModel
+    {
+
+        /// <summary>
+        /// Gets or sets the text of the Todo item.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("text", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Text { get; set; }
+
+    }
+
+    /// <summary>
+    /// Represents the model for a created Todo item.
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class CreatedTodoItemModel
+    {
+
+        /// <summary>
+        /// Gets or sets the ID of the created Todo item.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Id { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ProblemDetails
+    {
+
+        [Newtonsoft.Json.JsonProperty("type", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Type { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("title", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Title { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("status", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int? Status { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("detail", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Detail { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("instance", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Instance { get; set; }
+
+        private System.Collections.Generic.IDictionary<string, object> _additionalProperties;
+
+        [Newtonsoft.Json.JsonExtensionData]
+        public System.Collections.Generic.IDictionary<string, object> AdditionalProperties
+        {
+            get { return _additionalProperties ?? (_additionalProperties = new System.Collections.Generic.Dictionary<string, object>()); }
+            set { _additionalProperties = value; }
+        }
+
+    }
+
+    /// <summary>
+    /// Represents a Todo item.
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class TodoItemModel
+    {
+
+        /// <summary>
+        /// Gets or sets the ID of the Todo item.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Gets or sets the text of the Todo item.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("text", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Text { get; set; }
+
+        /// <summary>
+        /// Gets or sets the date and time the item was created.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("createdAt", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset CreatedAt { get; set; }
+
+        /// <summary>
+        /// Gets or sets the date and time the item was completed.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("completedAt", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset? CompletedAt { get; set; }
+
+        /// <summary>
+        /// Gets or sets the date and time the Todo item was last updated.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("lastUpdated", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset LastUpdated { get; set; }
+
+        /// <summary>
+        /// Gets or sets the optional priority of the Todo item.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("priority", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
+        public TodoPriority Priority { get; set; }
+
+    }
+
+    /// <summary>
+    /// Represents a collection of Todo items.
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class TodoListViewModel
+    {
+
+        /// <summary>
+        /// Gets or sets the Todo item(s).
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("items", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.Collections.Generic.ICollection<TodoItemModel> Items { get; set; }
+
+    }
+
+    /// <summary>
+    /// The priority levels for a Todo item.
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public enum TodoPriority
+    {
+
+        [System.Runtime.Serialization.EnumMember(Value = @"Normal")]
+        Normal = 0,
+
+        [System.Runtime.Serialization.EnumMember(Value = @"Low")]
+        Low = 1,
+
+        [System.Runtime.Serialization.EnumMember(Value = @"High")]
+        High = 2,
+
+    }
+
+    /// <summary>
+    /// Represents the model for updating the priority of a Todo item.
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class UpdateTodoItemPriorityModel
+    {
+
+        /// <summary>
+        /// Gets or sets the new priority of the Todo item.
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("priority", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
+        public TodoPriority Priority { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_b071608681806e68/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_b071608681806e68/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..6a3e890499
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_b071608681806e68/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,759 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<int> ProductsPOSTAsync(Product body)
+        {
+            return ProductsPOSTAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<int> ProductsPOSTAsync(Product body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<int>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAllAsync()
+        {
+            return ProductsAllAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAllAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> ProductsGETAsync(int id)
+        {
+            return ProductsGETAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> ProductsGETAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products/{id}"
+                    urlBuilder_.Append("products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task ProductsPUTAsync(int id, Product body)
+        {
+            return ProductsPUTAsync(id, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task ProductsPUTAsync(int id, Product body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("PUT");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products/{id}"
+                    urlBuilder_.Append("products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task ProductsPATCHAsync(int id, System.Collections.Generic.IDictionary<string, object> body)
+        {
+            return ProductsPATCHAsync(id, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task ProductsPATCHAsync(int id, System.Collections.Generic.IDictionary<string, object> body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("PATCH");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products/{id}"
+                    urlBuilder_.Append("products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task ProductsDELETEAsync(int id)
+        {
+            return ProductsDELETEAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task ProductsDELETEAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products/{id}"
+                    urlBuilder_.Append("products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int? Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/AnnotationsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/AnnotationsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..73d841b894
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/AnnotationsRequestBuilder.verified.cs
@@ -0,0 +1,77 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AnnotationsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The AsParameters property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder AsParameters
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The fruit property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder Fruit
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndEnum property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder IFromFileAndEnum
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder IFromFileAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromObjectAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder IFromObjectAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The multipleForms property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder MultipleForms
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The singleForm property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder SingleForm
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AnnotationsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AnnotationsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/AsParameters/AsParametersRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/AsParameters/AsParametersRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c314460094
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/AsParameters/AsParametersRequestBuilder.verified.cs
@@ -0,0 +1,117 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\AsParameters
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AsParametersRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AsParametersRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/AsParameters?paramEight={paramEight}&paramFour={paramFour}&paramSix={paramSix}&paramTen={paramTen}&paramTwelve={paramTwelve}&paramTwo={paramTwo}{&paramEleven*,paramFive*,paramNine*,paramOne*,paramSeven*,paramThree*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AsParametersRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/AsParameters?paramEight={paramEight}&paramFour={paramFour}&paramSix={paramSix}&paramTen={paramTen}&paramTwelve={paramTwelve}&paramTwo={paramTwo}{&paramEleven*,paramFive*,paramNine*,paramOne*,paramSeven*,paramThree*}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class AsParametersRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            [QueryParameter("paramEight")]
+            public Time? ParamEight { get; set; }
+            [QueryParameter("paramEleven")]
+            public double? ParamEleven { get; set; }
+            [QueryParameter("paramFive")]
+            public Date? ParamFive { get; set; }
+            [QueryParameter("paramFour")]
+            public DateTimeOffset? ParamFour { get; set; }
+            [QueryParameter("paramNine")]
+            public int? ParamNine { get; set; }
+            /// <summary>Description</summary>
+            [QueryParameter("paramOne")]
+            public Guid? ParamOne { get; set; }
+            [QueryParameter("paramSeven")]
+            public Time? ParamSeven { get; set; }
+            [QueryParameter("paramSix")]
+            public Date? ParamSix { get; set; }
+            [QueryParameter("paramTen")]
+            public int? ParamTen { get; set; }
+            [QueryParameter("paramThree")]
+            public DateTimeOffset? ParamThree { get; set; }
+            [QueryParameter("paramTwelve")]
+            public double? ParamTwelve { get; set; }
+            [QueryParameter("paramTwo")]
+            public Guid? ParamTwo { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class AsParametersRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AsParameters.AsParametersRequestBuilder.AsParametersRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/Fruit/FruitRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/Fruit/FruitRequestBuilder.verified.cs
new file mode 100644
index 0000000000..1f743a2e89
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/Fruit/FruitRequestBuilder.verified.cs
@@ -0,0 +1,48 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\fruit
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FruitRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.annotations.fruit.item collection</summary>
+        /// <param name="position">The id of the fruit that will be created</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.FruitRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/Fruit/Item/FruitItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/Fruit/Item/FruitItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..2408b0a15d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/Fruit/Item/FruitItemRequestBuilder.verified.cs
@@ -0,0 +1,97 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\fruit\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FruitItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FruitItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/fruit/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Create a fruit
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit"/></returns>
+        /// <param name="body">Description for Schema</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Create a fruit
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Description for Schema</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.Fruit.Item.FruitItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class FruitItemRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
new file mode 100644
index 0000000000..72889a4a75
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\IFromFileAndEnum
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndEnumRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndEnum", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndEnum", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndEnumRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..6cf1bf4636
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\IFromFileAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromFileAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromFileAndString.IFromFileAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
new file mode 100644
index 0000000000..654ac6720d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
@@ -0,0 +1,67 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class IFromObjectAndStringPostRequestBody : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The tags property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Tags { get; set; }
+#nullable restore
+#else
+        public string Tags { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public IFromObjectAndStringPostRequestBody() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "tags", n => { Tags = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("tags", Tags);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..6fa13e87ac
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\IFromObjectAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromObjectAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromObjectAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/IFromObjectAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.IFromObjectAndString.IFromObjectAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromObjectAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/MultipleForms/MultipleFormsPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/MultipleForms/MultipleFormsPostRequestBody.verified.cs
new file mode 100644
index 0000000000..1daf33186d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/MultipleForms/MultipleFormsPostRequestBody.verified.cs
@@ -0,0 +1,115 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class MultipleFormsPostRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The city property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? City { get; set; }
+#nullable restore
+#else
+        public string City { get; set; }
+#endif
+        /// <summary>Description for FirstName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>Description for LastName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>The state property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? State { get; set; }
+#nullable restore
+#else
+        public string State { get; set; }
+#endif
+        /// <summary>Description for Street</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Street { get; set; }
+#nullable restore
+#else
+        public string Street { get; set; }
+#endif
+        /// <summary>The zipCode property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? ZipCode { get; set; }
+#nullable restore
+#else
+        public string ZipCode { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public MultipleFormsPostRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "city", n => { City = n.GetStringValue(); } },
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+                { "state", n => { State = n.GetStringValue(); } },
+                { "street", n => { Street = n.GetStringValue(); } },
+                { "zipCode", n => { ZipCode = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("city", City);
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+            writer.WriteStringValue("state", State);
+            writer.WriteStringValue("street", Street);
+            writer.WriteStringValue("zipCode", ZipCode);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/MultipleForms/MultipleFormsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/MultipleForms/MultipleFormsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..78e5cdc7fc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/MultipleForms/MultipleFormsRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\multipleForms
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class MultipleFormsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/multipleForms", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/multipleForms", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.MultipleForms.MultipleFormsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class MultipleFormsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/SingleForm/SingleFormRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/SingleForm/SingleFormRequestBuilder.verified.cs
new file mode 100644
index 0000000000..9f80518ba2
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Annotations/SingleForm/SingleFormRequestBuilder.verified.cs
@@ -0,0 +1,91 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \annotations\singleForm
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class SingleFormRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SingleFormRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/singleForm", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SingleFormRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/annotations/singleForm", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/x-www-form-urlencoded", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.SingleForm.SingleFormRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SingleFormRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..1d9f32b2bc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,61 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The annotations property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder Annotations
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Annotations.AnnotationsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The TypeWithTryParse property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder TypeWithTryParse
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The WithOpenApi property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder WithOpenApi
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The XmlComments property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder XmlComments
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/AsParametersRecord.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/AsParametersRecord.verified.cs
new file mode 100644
index 0000000000..b703f26d0a
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/AsParametersRecord.verified.cs
@@ -0,0 +1,94 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class AsParametersRecord : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The paramEight property</summary>
+        public Time? ParamEight { get; set; }
+        /// <summary>The paramEleven property</summary>
+        public double? ParamEleven { get; set; }
+        /// <summary>The paramFive property</summary>
+        public Date? ParamFive { get; set; }
+        /// <summary>The paramFour property</summary>
+        public DateTimeOffset? ParamFour { get; set; }
+        /// <summary>The paramNine property</summary>
+        public int? ParamNine { get; set; }
+        /// <summary>The paramOne property</summary>
+        public Guid? ParamOne { get; set; }
+        /// <summary>The paramSeven property</summary>
+        public Time? ParamSeven { get; set; }
+        /// <summary>The paramSix property</summary>
+        public Date? ParamSix { get; set; }
+        /// <summary>The paramTen property</summary>
+        public int? ParamTen { get; set; }
+        /// <summary>The paramThree property</summary>
+        public DateTimeOffset? ParamThree { get; set; }
+        /// <summary>The paramTwelve property</summary>
+        public double? ParamTwelve { get; set; }
+        /// <summary>The paramTwo property</summary>
+        public Guid? ParamTwo { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AsParametersRecord();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "paramEight", n => { ParamEight = n.GetTimeValue(); } },
+                { "paramEleven", n => { ParamEleven = n.GetDoubleValue(); } },
+                { "paramFive", n => { ParamFive = n.GetDateValue(); } },
+                { "paramFour", n => { ParamFour = n.GetDateTimeOffsetValue(); } },
+                { "paramNine", n => { ParamNine = n.GetIntValue(); } },
+                { "paramOne", n => { ParamOne = n.GetGuidValue(); } },
+                { "paramSeven", n => { ParamSeven = n.GetTimeValue(); } },
+                { "paramSix", n => { ParamSix = n.GetDateValue(); } },
+                { "paramTen", n => { ParamTen = n.GetIntValue(); } },
+                { "paramThree", n => { ParamThree = n.GetDateTimeOffsetValue(); } },
+                { "paramTwelve", n => { ParamTwelve = n.GetDoubleValue(); } },
+                { "paramTwo", n => { ParamTwo = n.GetGuidValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteTimeValue("paramEight", ParamEight);
+            writer.WriteDoubleValue("paramEleven", ParamEleven);
+            writer.WriteDateValue("paramFive", ParamFive);
+            writer.WriteDateTimeOffsetValue("paramFour", ParamFour);
+            writer.WriteIntValue("paramNine", ParamNine);
+            writer.WriteGuidValue("paramOne", ParamOne);
+            writer.WriteTimeValue("paramSeven", ParamSeven);
+            writer.WriteDateValue("paramSix", ParamSix);
+            writer.WriteIntValue("paramTen", ParamTen);
+            writer.WriteDateTimeOffsetValue("paramThree", ParamThree);
+            writer.WriteDoubleValue("paramTwelve", ParamTwelve);
+            writer.WriteGuidValue("paramTwo", ParamTwo);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/CurrenciesRate.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/CurrenciesRate.verified.cs
new file mode 100644
index 0000000000..b11e7225fd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/CurrenciesRate.verified.cs
@@ -0,0 +1,69 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class CurrenciesRate : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Currency From</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CurrencyFrom { get; set; }
+#nullable restore
+#else
+        public string CurrencyFrom { get; set; }
+#endif
+        /// <summary>The currencyTo property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CurrencyTo { get; set; }
+#nullable restore
+#else
+        public string CurrencyTo { get; set; }
+#endif
+        /// <summary>The rate property</summary>
+        public double? Rate { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "currencyFrom", n => { CurrencyFrom = n.GetStringValue(); } },
+                { "currencyTo", n => { CurrencyTo = n.GetStringValue(); } },
+                { "rate", n => { Rate = n.GetDoubleValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("currencyFrom", CurrencyFrom);
+            writer.WriteStringValue("currencyTo", CurrencyTo);
+            writer.WriteDoubleValue("rate", Rate);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Fruit.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Fruit.verified.cs
new file mode 100644
index 0000000000..8ce9761fec
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Fruit.verified.cs
@@ -0,0 +1,56 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Description for Schema
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class Fruit : IParsable
+    {
+        /// <summary>The name property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Name { get; set; }
+#nullable restore
+#else
+        public string Name { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Fruit();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "name", n => { Name = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("name", Name);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/OrganizationCustomExchangeRatesDto.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/OrganizationCustomExchangeRatesDto.verified.cs
new file mode 100644
index 0000000000..5cd77a470e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/OrganizationCustomExchangeRatesDto.verified.cs
@@ -0,0 +1,58 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class OrganizationCustomExchangeRatesDto : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The currenciesRates property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate>? CurrenciesRates { get; set; }
+#nullable restore
+#else
+        public List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate> CurrenciesRates { get; set; }
+#endif
+        /// <summary>The isUpdated property</summary>
+        public bool? IsUpdated { get; private set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "currenciesRates", n => { CurrenciesRates = n.GetCollectionOfObjectValues<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate>(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate.CreateFromDiscriminatorValue)?.AsList(); } },
+                { "isUpdated", n => { IsUpdated = n.GetBoolValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteCollectionOfObjectValues<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CurrenciesRate>("currenciesRates", CurrenciesRates);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Person.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Person.verified.cs
new file mode 100644
index 0000000000..50466e2a4d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Person.verified.cs
@@ -0,0 +1,65 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Person : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The firstName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>The lastName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/PersonAnnotated.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/PersonAnnotated.verified.cs
new file mode 100644
index 0000000000..b21d6a6ae7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/PersonAnnotated.verified.cs
@@ -0,0 +1,65 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class PersonAnnotated : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Description for FirstName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>Description for LastName</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PersonAnnotated();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Product.verified.cs
new file mode 100644
index 0000000000..77c098a9d5
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/Product.verified.cs
@@ -0,0 +1,63 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents a product
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class Product : ApiException, IParsable
+    {
+        /// <summary>Describes the product</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>Uniquely identifies the product</summary>
+        public int? Id { get; set; }
+        /// <summary>The primary error message.</summary>
+        public override string Message { get => base.Message; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/WeatherForecast.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/WeatherForecast.verified.cs
new file mode 100644
index 0000000000..8dbad82e4f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/Models/WeatherForecast.verified.cs
@@ -0,0 +1,67 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class WeatherForecast : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The date property</summary>
+        public Date? Date { get; set; }
+        /// <summary>The summary property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Summary { get; set; }
+#nullable restore
+#else
+        public string Summary { get; set; }
+#endif
+        /// <summary>The temperatureC property</summary>
+        public int? TemperatureC { get; set; }
+        /// <summary>The temperatureF property</summary>
+        public int? TemperatureF { get; private set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "date", n => { Date = n.GetDateValue(); } },
+                { "summary", n => { Summary = n.GetStringValue(); } },
+                { "temperatureC", n => { TemperatureC = n.GetIntValue(); } },
+                { "temperatureF", n => { TemperatureF = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDateValue("date", Date);
+            writer.WriteStringValue("summary", Summary);
+            writer.WriteIntValue("temperatureC", TemperatureC);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/TypeWithTryParse/Item/WithTryParseItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/TypeWithTryParse/Item/WithTryParseItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..055941e1a7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/TypeWithTryParse/Item/WithTryParseItemRequestBuilder.verified.cs
@@ -0,0 +1,85 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \TypeWithTryParse\{tryParse}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WithTryParseItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithTryParseItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse/{tryParse}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithTryParseItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse/{tryParse}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WithTryParseItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/TypeWithTryParse/TypeWithTryParseRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/TypeWithTryParse/TypeWithTryParseRequestBuilder.verified.cs
new file mode 100644
index 0000000000..a7f8892ecd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/TypeWithTryParse/TypeWithTryParseRequestBuilder.verified.cs
@@ -0,0 +1,48 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \TypeWithTryParse
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class TypeWithTryParseRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("tryParse", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.Item.WithTryParseItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TypeWithTryParseRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.TypeWithTryParse.TypeWithTryParseRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public TypeWithTryParseRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/TypeWithTryParse", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromBody/IFromBodyRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromBody/IFromBodyRequestBuilder.verified.cs
new file mode 100644
index 0000000000..9f5b657944
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromBody/IFromBodyRequestBuilder.verified.cs
@@ -0,0 +1,91 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromBody
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromBodyRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromBodyRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromBody", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromBodyRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromBody", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.OrganizationCustomExchangeRatesDto body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromBodyRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFile/IFromFileRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFile/IFromFileRequestBuilder.verified.cs
new file mode 100644
index 0000000000..61b5424207
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFile/IFromFileRequestBuilder.verified.cs
@@ -0,0 +1,105 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFile
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFile?queryParameter={queryParameter}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFile?queryParameter={queryParameter}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class IFromFileRequestBuilderPostQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("queryParameter")]
+            public string? QueryParameter { get; set; }
+#nullable restore
+#else
+            [QueryParameter("queryParameter")]
+            public string QueryParameter { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileRequestBuilderPostRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder.IFromFileRequestBuilderPostQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
new file mode 100644
index 0000000000..1500ddcbce
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileAndEnum/IFromFileAndEnumRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFileAndEnum
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndEnumRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndEnum", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndEnumRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndEnum", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndEnumRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..106c2340f6
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileAndString/IFromFileAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFileAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileCollection/IFromFileCollectionRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileCollection/IFromFileCollectionRequestBuilder.verified.cs
new file mode 100644
index 0000000000..4afacd0856
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromFileCollection/IFromFileCollectionRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromFileCollection
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromFileCollectionRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileCollectionRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileCollection", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromFileCollectionRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromFileCollection", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromFileCollectionRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
new file mode 100644
index 0000000000..a3c1dcaffc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromObjectAndString/IFromObjectAndStringPostRequestBody.verified.cs
@@ -0,0 +1,67 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class IFromObjectAndStringPostRequestBody : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Person, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The tags property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Tags { get; set; }
+#nullable restore
+#else
+        public string Tags { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public IFromObjectAndStringPostRequestBody() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "tags", n => { Tags = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("tags", Tags);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
new file mode 100644
index 0000000000..59724371cd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/IFromObjectAndString/IFromObjectAndStringRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\IFromObjectAndString
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class IFromObjectAndStringRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromObjectAndString", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public IFromObjectAndStringRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/IFromObjectAndString", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class IFromObjectAndStringRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/MultipleForms/MultipleFormsPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/MultipleForms/MultipleFormsPostRequestBody.verified.cs
new file mode 100644
index 0000000000..0b0a90cc76
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/MultipleForms/MultipleFormsPostRequestBody.verified.cs
@@ -0,0 +1,115 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class MultipleFormsPostRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The city property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? City { get; set; }
+#nullable restore
+#else
+        public string City { get; set; }
+#endif
+        /// <summary>The firstName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? FirstName { get; set; }
+#nullable restore
+#else
+        public string FirstName { get; set; }
+#endif
+        /// <summary>The lastName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? LastName { get; set; }
+#nullable restore
+#else
+        public string LastName { get; set; }
+#endif
+        /// <summary>The state property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? State { get; set; }
+#nullable restore
+#else
+        public string State { get; set; }
+#endif
+        /// <summary>The street property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Street { get; set; }
+#nullable restore
+#else
+        public string Street { get; set; }
+#endif
+        /// <summary>The zipCode property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? ZipCode { get; set; }
+#nullable restore
+#else
+        public string ZipCode { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public MultipleFormsPostRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "city", n => { City = n.GetStringValue(); } },
+                { "firstName", n => { FirstName = n.GetStringValue(); } },
+                { "lastName", n => { LastName = n.GetStringValue(); } },
+                { "state", n => { State = n.GetStringValue(); } },
+                { "street", n => { Street = n.GetStringValue(); } },
+                { "zipCode", n => { ZipCode = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("city", City);
+            writer.WriteStringValue("firstName", FirstName);
+            writer.WriteStringValue("lastName", LastName);
+            writer.WriteStringValue("state", State);
+            writer.WriteStringValue("street", Street);
+            writer.WriteStringValue("zipCode", ZipCode);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/MultipleForms/MultipleFormsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/MultipleForms/MultipleFormsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e6aca56210
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/MultipleForms/MultipleFormsRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\multipleForms
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class MultipleFormsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/multipleForms", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleFormsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/multipleForms", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class MultipleFormsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/Weatherforecast/WeatherforecastRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/Weatherforecast/WeatherforecastRequestBuilder.verified.cs
new file mode 100644
index 0000000000..94751af1af
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/Weatherforecast/WeatherforecastRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi\weatherforecast
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WeatherforecastRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherforecastRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/weatherforecast", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherforecastRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi/weatherforecast", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.WeatherForecast.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WeatherforecastRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/WithOpenApiRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/WithOpenApiRequestBuilder.verified.cs
new file mode 100644
index 0000000000..ce7b199d2d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/WithOpenApi/WithOpenApiRequestBuilder.verified.cs
@@ -0,0 +1,83 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \WithOpenApi
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WithOpenApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The IFromBody property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder IFromBody
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromBody.IFromBodyRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFile property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder IFromFile
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFile.IFromFileRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndEnum property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder IFromFileAndEnum
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndEnum.IFromFileAndEnumRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder IFromFileAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileAndString.IFromFileAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromFileCollection property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder IFromFileCollection
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromFileCollection.IFromFileCollectionRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The IFromObjectAndString property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder IFromObjectAndString
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.IFromObjectAndString.IFromObjectAndStringRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The multipleForms property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder MultipleForms
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.MultipleForms.MultipleFormsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The weatherforecast property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder Weatherforecast
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.Weatherforecast.WeatherforecastRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithOpenApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.WithOpenApi.WithOpenApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithOpenApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/WithOpenApi", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/Car/CarRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/Car/CarRequestBuilder.verified.cs
new file mode 100644
index 0000000000..00c5cffc6e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/Car/CarRequestBuilder.verified.cs
@@ -0,0 +1,135 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\Car
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.item collection</summary>
+        /// <param name="position">The product id</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.item collection</summary>
+        /// <param name="position">The product id</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car?Id={Id}{&Description*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car?Id={Id}{&Description*}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarRequestBuilderGetQueryParameters 
+        {
+            /// <summary>Describes the product</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public string? Description { get; set; }
+#nullable restore
+#else
+            public string Description { get; set; }
+#endif
+            /// <summary>Uniquely identifies the product</summary>
+            public int? Id { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder.CarRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/Car/Item/CarItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/Car/Item/CarItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..92c6c82214
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/Car/Item/CarItemRequestBuilder.verified.cs
@@ -0,0 +1,92 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\Car\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/Car/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.Item.CarItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/CarWithProduces/CarWithProducesRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/CarWithProduces/CarWithProducesRequestBuilder.verified.cs
new file mode 100644
index 0000000000..377741915d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/CarWithProduces/CarWithProducesRequestBuilder.verified.cs
@@ -0,0 +1,101 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\CarWithProduces
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarWithProducesRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProduces?id={id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProduces?id={id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesRequestBuilderGetQueryParameters 
+        {
+            [QueryParameter("id")]
+            public int? Id { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder.CarWithProducesRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/CarWithProducesDefaultResponseType/CarWithProducesDefaultResponseTypeRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/CarWithProducesDefaultResponseType/CarWithProducesDefaultResponseTypeRequestBuilder.verified.cs
new file mode 100644
index 0000000000..468b0235ce
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/CarWithProducesDefaultResponseType/CarWithProducesDefaultResponseTypeRequestBuilder.verified.cs
@@ -0,0 +1,106 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments\CarWithProducesDefaultResponseType
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CarWithProducesDefaultResponseTypeRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesDefaultResponseTypeRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProducesDefaultResponseType?id={id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CarWithProducesDefaultResponseTypeRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments/CarWithProducesDefaultResponseType?id={id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        /// <exception cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product">When receiving a 4XX or 5XX status code</exception>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var errorMapping = new Dictionary<string, ParsableFactory<IParsable>>
+            {
+                { "XXX", global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue },
+            };
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters 
+        {
+            [QueryParameter("id")]
+            public int? Id { get; set; }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CarWithProducesDefaultResponseTypeRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder.CarWithProducesDefaultResponseTypeRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/XmlCommentsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/XmlCommentsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..4ea49e8371
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ba95e19a2268ba0d/XmlComments/XmlCommentsRequestBuilder.verified.cs
@@ -0,0 +1,53 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \XmlComments
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class XmlCommentsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The Car property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder Car
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.Car.CarRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The CarWithProduces property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder CarWithProduces
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProduces.CarWithProducesRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The CarWithProducesDefaultResponseType property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder CarWithProducesDefaultResponseType
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.CarWithProducesDefaultResponseType.CarWithProducesDefaultResponseTypeRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public XmlCommentsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.XmlComments.XmlCommentsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public XmlCommentsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/XmlComments", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_bd8e5ffa55d2e869/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_bd8e5ffa55d2e869/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..5036e7874a
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_bd8e5ffa55d2e869/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,368 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>User created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task CreateUserAsync(Body body)
+        {
+            return CreateUserAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>User created</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task CreateUserAsync(Body body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/users"
+                    urlBuilder_.Append("api/users");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 201)
+                        {
+                            return;
+                        }
+                        else
+                        if (status_ == 400)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Invalid request", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Body
+    {
+
+        [Newtonsoft.Json.JsonProperty("email", Required = Newtonsoft.Json.Required.Always)]
+        [System.ComponentModel.DataAnnotations.Required(AllowEmptyStrings = true)]
+        public string Email { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("password", Required = Newtonsoft.Json.Required.Always)]
+        [System.ComponentModel.DataAnnotations.Required(AllowEmptyStrings = true)]
+        public string Password { get; set; }
+
+        private System.Collections.Generic.IDictionary<string, object> _additionalProperties;
+
+        [Newtonsoft.Json.JsonExtensionData]
+        public System.Collections.Generic.IDictionary<string, object> AdditionalProperties
+        {
+            get { return _additionalProperties ?? (_additionalProperties = new System.Collections.Generic.Dictionary<string, object>()); }
+            set { _additionalProperties = value; }
+        }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Addresses/AddressesRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Addresses/AddressesRequestBuilder.verified.cs
new file mode 100644
index 0000000000..7fba6168de
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Addresses/AddressesRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \addresses
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AddressesRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The validate property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder Validate
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.AddressesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AddressesRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/addresses", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.AddressesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AddressesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/addresses", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Addresses/Validate/ValidateRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Addresses/Validate/ValidateRequestBuilder.verified.cs
new file mode 100644
index 0000000000..437c3fa9f0
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Addresses/Validate/ValidateRequestBuilder.verified.cs
@@ -0,0 +1,110 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \addresses\validate
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ValidateRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ValidateRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/addresses/validate?country={country}{&city*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ValidateRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/addresses/validate?country={country}{&city*}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ValidateRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+            /// <summary>Name of city</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("city")]
+            public string? City { get; set; }
+#nullable restore
+#else
+            [QueryParameter("city")]
+            public string City { get; set; }
+#endif
+            /// <summary>3-letter ISO country code</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("country")]
+            public string? Country { get; set; }
+#nullable restore
+#else
+            [QueryParameter("country")]
+            public string Country { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ValidateRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Carts/CartsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Carts/CartsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..99b9fd258f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Carts/CartsRequestBuilder.verified.cs
@@ -0,0 +1,117 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \carts
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CartsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.carts.item collection</summary>
+        /// <param name="position">The cart identifier</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.carts.item collection</summary>
+        /// <param name="position">The cart identifier</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.CartsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CartsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/carts", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.CartsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CartsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/carts", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json, text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.CartsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.CartsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.CartsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CartsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Carts/Item/CartsItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Carts/Item/CartsItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..36c4f27c74
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Carts/Item/CartsItemRequestBuilder.verified.cs
@@ -0,0 +1,134 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \carts\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CartsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CartsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/carts/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CartsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/carts/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Requires admin privileges
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart?> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// External docs for CartsByIdGet <see href="https://tempuri.org/carts-by-id-get" />
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Requires admin privileges
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json, text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json, text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.Item.CartsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CartsItemRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CartsItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Country/CountryRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Country/CountryRequestBuilder.verified.cs
new file mode 100644
index 0000000000..2f0b117fb6
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Country/CountryRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \country
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CountryRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The validate property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder Validate
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.CountryRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CountryRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/country", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.CountryRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CountryRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/country", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Country/Validate/ValidateRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Country/Validate/ValidateRequestBuilder.verified.cs
new file mode 100644
index 0000000000..70e1a9bb4f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Country/Validate/ValidateRequestBuilder.verified.cs
@@ -0,0 +1,99 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \country\validate
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ValidateRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ValidateRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/country/validate{?country*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ValidateRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/country/validate{?country*}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ValidateRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("country")]
+            public string? Country { get; set; }
+#nullable restore
+#else
+            [QueryParameter("country")]
+            public string Country { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ValidateRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Dragons/DragonsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Dragons/DragonsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..8e9b74fdc9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Dragons/DragonsRequestBuilder.verified.cs
@@ -0,0 +1,89 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \dragons
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class DragonsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons.DragonsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DragonsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/dragons", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons.DragonsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public DragonsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/dragons", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons.DragonsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons.DragonsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons.DragonsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class DragonsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/FilesRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/FilesRequestBuilder.verified.cs
new file mode 100644
index 0000000000..5486f6a6ca
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/FilesRequestBuilder.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \files
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FilesRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The formWithFile property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile.FormWithFileRequestBuilder FormWithFile
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile.FormWithFileRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The multiple property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple.MultipleRequestBuilder Multiple
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple.MultipleRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The single property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace.SingleRequestBuilder Single
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace.SingleRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.files.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("name", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FilesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FilesRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FilesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FilesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/FormWithFile/FormWithFileRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/FormWithFile/FormWithFileRequestBuilder.verified.cs
new file mode 100644
index 0000000000..cc95ee02ec
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/FormWithFile/FormWithFileRequestBuilder.verified.cs
@@ -0,0 +1,89 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \files\form-with-file
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class FormWithFileRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile.FormWithFileRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FormWithFileRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/form-with-file", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile.FormWithFileRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public FormWithFileRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/form-with-file", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile.FormWithFileRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile.FormWithFileRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FormWithFile.FormWithFileRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class FormWithFileRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/Item/WithNameItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/Item/WithNameItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..8a077807be
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/Item/WithNameItemRequestBuilder.verified.cs
@@ -0,0 +1,203 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \files\{name}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WithNameItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithNameItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/{name}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithNameItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/{name}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse?> GetAsWithNameGetResponseAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse> GetAsWithNameGetResponseAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        [Obsolete("This method is obsolete. Use GetAsWithNameGetResponseAsync instead.")]
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Composed type wrapper for classes <see cref="byte[]"/>
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WithNameGetResponse : IComposedTypeWrapper, IParsable
+        {
+            /// <summary>Composed type representation for type <see cref="byte[]"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public byte[]? Binary { get; set; }
+#nullable restore
+#else
+            public byte[] Binary { get; set; }
+#endif
+            /// <summary>
+            /// Creates a new instance of the appropriate class based on discriminator value
+            /// </summary>
+            /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse"/></returns>
+            /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+            public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse CreateFromDiscriminatorValue(IParseNode parseNode)
+            {
+                if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+                var mappingValue = parseNode.GetChildNode("")?.GetStringValue();
+                var result = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameGetResponse();
+                if(parseNode.GetByteArrayValue() is byte[] binaryValue)
+                {
+                    result.Binary = binaryValue;
+                }
+                return result;
+            }
+            /// <summary>
+            /// The deserialization information for the current model
+            /// </summary>
+            /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+            public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+            {
+                return new Dictionary<string, Action<IParseNode>>();
+            }
+            /// <summary>
+            /// Serializes information the current object
+            /// </summary>
+            /// <param name="writer">Serialization writer to use to serialize this model</param>
+            public virtual void Serialize(ISerializationWriter writer)
+            {
+                if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+                if(Binary != null)
+                {
+                    writer.WriteByteArrayValue(null, Binary);
+                }
+            }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WithNameItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Composed type wrapper for classes <see cref="byte[]"/>
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WithNameResponse : IComposedTypeWrapper, IParsable
+        {
+            /// <summary>Composed type representation for type <see cref="byte[]"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public byte[]? Binary { get; set; }
+#nullable restore
+#else
+            public byte[] Binary { get; set; }
+#endif
+            /// <summary>
+            /// Creates a new instance of the appropriate class based on discriminator value
+            /// </summary>
+            /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse"/></returns>
+            /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+            public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse CreateFromDiscriminatorValue(IParseNode parseNode)
+            {
+                if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+                var mappingValue = parseNode.GetChildNode("")?.GetStringValue();
+                var result = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Item.WithNameItemRequestBuilder.WithNameResponse();
+                if(parseNode.GetByteArrayValue() is byte[] binaryValue)
+                {
+                    result.Binary = binaryValue;
+                }
+                return result;
+            }
+            /// <summary>
+            /// The deserialization information for the current model
+            /// </summary>
+            /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+            public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+            {
+                return new Dictionary<string, Action<IParseNode>>();
+            }
+            /// <summary>
+            /// Serializes information the current object
+            /// </summary>
+            /// <param name="writer">Serialization writer to use to serialize this model</param>
+            public virtual void Serialize(ISerializationWriter writer)
+            {
+                if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+                if(Binary != null)
+                {
+                    writer.WriteByteArrayValue(null, Binary);
+                }
+            }
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/Multiple/MultipleRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/Multiple/MultipleRequestBuilder.verified.cs
new file mode 100644
index 0000000000..ee1756e790
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/Multiple/MultipleRequestBuilder.verified.cs
@@ -0,0 +1,89 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \files\multiple
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class MultipleRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple.MultipleRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/multiple", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple.MultipleRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public MultipleRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/multiple", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple.MultipleRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple.MultipleRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.Multiple.MultipleRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class MultipleRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/SingleNamespace/SingleRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/SingleNamespace/SingleRequestBuilder.verified.cs
new file mode 100644
index 0000000000..26eaec4466
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Files/SingleNamespace/SingleRequestBuilder.verified.cs
@@ -0,0 +1,89 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \files\single
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class SingleRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace.SingleRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SingleRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/single", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace.SingleRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SingleRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/files/single", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace.SingleRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace.SingleRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.SingleNamespace.SingleRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SingleRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Issue3013/Get/GetRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Issue3013/Get/GetRequestBuilder.verified.cs
new file mode 100644
index 0000000000..74911b8dc9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Issue3013/Get/GetRequestBuilder.verified.cs
@@ -0,0 +1,86 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \Issue3013\Get
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class GetRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get.GetRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Issue3013/Get", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get.GetRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public GetRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Issue3013/Get", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json, text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get.GetRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get.GetRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get.GetRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class GetRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Issue3013/Issue3013RequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Issue3013/Issue3013RequestBuilder.verified.cs
new file mode 100644
index 0000000000..ba52057f89
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Issue3013/Issue3013RequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \Issue3013
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class Issue3013RequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The GetPath property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get.GetRequestBuilder GetPath
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Get.GetRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Issue3013RequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public Issue3013RequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Issue3013", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Issue3013RequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public Issue3013RequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Issue3013", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..a964f8c532
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,145 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The addresses property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.AddressesRequestBuilder Addresses
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Addresses.AddressesRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The carts property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.CartsRequestBuilder Carts
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Carts.CartsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The country property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.CountryRequestBuilder Country
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Country.CountryRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The dragons property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons.DragonsRequestBuilder Dragons
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Dragons.DragonsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The files property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FilesRequestBuilder Files
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Files.FilesRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The Issue3013 property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Issue3013RequestBuilder Issue3013
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Issue3013.Issue3013RequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The kittens property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens.KittensRequestBuilder Kittens
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens.KittensRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The orders property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders.OrdersRequestBuilder Orders
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders.OrdersRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The payments property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.PaymentsRequestBuilder Payments
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.PaymentsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The promotions property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions.PromotionsRequestBuilder Promotions
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions.PromotionsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The registrations property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsRequestBuilder Registrations
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The registrationsWithEnumParameter property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter.RegistrationsWithEnumParameterRequestBuilder RegistrationsWithEnumParameter
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter.RegistrationsWithEnumParameterRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The registrationsWithIgnoreProperties property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties.RegistrationsWithIgnorePropertiesRequestBuilder RegistrationsWithIgnoreProperties
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties.RegistrationsWithIgnorePropertiesRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The shapes property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder Shapes
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The stores property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder Stores
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The unicorns property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsRequestBuilder Unicorns
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The zipCodes property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.ZipCodesRequestBuilder ZipCodes
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.ZipCodesRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Kittens/KittensRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Kittens/KittensRequestBuilder.verified.cs
new file mode 100644
index 0000000000..9b3fabfde3
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Kittens/KittensRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \kittens
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KittensRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens.KittensRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KittensRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/kittens", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens.KittensRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KittensRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/kittens", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(UntypedNode body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens.KittensRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens.KittensRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Kittens.KittensRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class KittensRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Cart.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Cart.verified.cs
new file mode 100644
index 0000000000..ba75b1190f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Cart.verified.cs
@@ -0,0 +1,52 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Cart : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The cart type</summary>
+        public int? CartType { get; set; }
+        /// <summary>The cart identifier</summary>
+        public int? Id { get; private set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cart();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "cartType", n => { CartType = n.GetIntValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteIntValue("cartType", CartType);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Circle.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Circle.verified.cs
new file mode 100644
index 0000000000..332eb18ee6
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Circle.verified.cs
@@ -0,0 +1,60 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Circle : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Shape, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The radius property</summary>
+        public int? Radius { get; set; }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle"/> and sets the default values.
+        /// </summary>
+        public Circle() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "radius", n => { Radius = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteIntValue("radius", Radius);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/CreditCard.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/CreditCard.verified.cs
new file mode 100644
index 0000000000..acf3fa2026
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/CreditCard.verified.cs
@@ -0,0 +1,63 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class CreditCard : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The cardNumber property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CardNumber { get; set; }
+#nullable restore
+#else
+        public string CardNumber { get; set; }
+#endif
+        /// <summary>The expMonth property</summary>
+        public int? ExpMonth { get; set; }
+        /// <summary>The expYear property</summary>
+        public int? ExpYear { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "cardNumber", n => { CardNumber = n.GetStringValue(); } },
+                { "expMonth", n => { ExpMonth = n.GetIntValue(); } },
+                { "expYear", n => { ExpYear = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("cardNumber", CardNumber);
+            writer.WriteIntValue("expMonth", ExpMonth);
+            writer.WriteIntValue("expYear", ExpYear);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/DiscountType.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/DiscountType.verified.cs
new file mode 100644
index 0000000000..f847b26979
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/DiscountType.verified.cs
@@ -0,0 +1,20 @@
+// <auto-generated/>
+using System.Runtime.Serialization;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public enum DiscountType
+    #pragma warning restore CS1591
+    {
+        [EnumMember(Value = "Percentage")]
+        #pragma warning disable CS1591
+        Percentage,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "Amount")]
+        #pragma warning disable CS1591
+        Amount,
+        #pragma warning restore CS1591
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/PaymentRequest.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/PaymentRequest.verified.cs
new file mode 100644
index 0000000000..483114978d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/PaymentRequest.verified.cs
@@ -0,0 +1,65 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class PaymentRequest : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The creditCard property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard? CreditCard { get; set; }
+#nullable restore
+#else
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard CreditCard { get; set; }
+#endif
+        /// <summary>The transaction property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction? Transaction { get; set; }
+#nullable restore
+#else
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction Transaction { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PaymentRequest"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PaymentRequest CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PaymentRequest();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "creditCard", n => { CreditCard = n.GetObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard>(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard.CreateFromDiscriminatorValue); } },
+                { "transaction", n => { Transaction = n.GetObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction>(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction.CreateFromDiscriminatorValue); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.CreditCard>("creditCard", CreditCard);
+            writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction>("transaction", Transaction);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Product.verified.cs
new file mode 100644
index 0000000000..547ecaf118
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Product.verified.cs
@@ -0,0 +1,72 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    /// <summary>
+    /// Represents a product
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class Product : IParsable
+    {
+        /// <summary>Describes the product</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>Uniquely identifies the product</summary>
+        public int? Id { get; set; }
+        /// <summary>The price property</summary>
+        public double? Price { get; set; }
+        /// <summary>The status property</summary>
+        public int? Status { get; set; }
+        /// <summary>The status2 property</summary>
+        public int? Status2 { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+                { "price", n => { Price = n.GetDoubleValue(); } },
+                { "status", n => { Status = n.GetIntValue(); } },
+                { "status2", n => { Status2 = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+            writer.WriteDoubleValue("price", Price);
+            writer.WriteIntValue("status", Status);
+            writer.WriteIntValue("status2", Status2);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Promotion.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Promotion.verified.cs
new file mode 100644
index 0000000000..0cb92a9dea
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Promotion.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Promotion : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The discountType property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.DiscountType? DiscountType { get; set; }
+        /// <summary>The promoCode property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? PromoCode { get; set; }
+#nullable restore
+#else
+        public string PromoCode { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "discountType", n => { DiscountType = n.GetEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.DiscountType>(); } },
+                { "promo-code", n => { PromoCode = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.DiscountType>("discountType", DiscountType);
+            writer.WriteStringValue("promo-code", PromoCode);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Rectangle.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Rectangle.verified.cs
new file mode 100644
index 0000000000..2f5c0e54b4
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Rectangle.verified.cs
@@ -0,0 +1,64 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Rectangle : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Shape, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The height property</summary>
+        public int? Height { get; set; }
+        /// <summary>The width property</summary>
+        public int? Width { get; set; }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle"/> and sets the default values.
+        /// </summary>
+        public Rectangle() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "height", n => { Height = n.GetIntValue(); } },
+                { "width", n => { Width = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteIntValue("height", Height);
+            writer.WriteIntValue("width", Width);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Shape.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Shape.verified.cs
new file mode 100644
index 0000000000..92e3954fdd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Shape.verified.cs
@@ -0,0 +1,71 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Shape : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The name property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Name { get; set; }
+#nullable restore
+#else
+        public string Name { get; set; }
+#endif
+        /// <summary>The TypeName property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? TypeName { get; set; }
+#nullable restore
+#else
+        public string TypeName { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Shape"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Shape CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            var mappingValue = parseNode.GetChildNode("TypeName")?.GetStringValue();
+            return mappingValue switch
+            {
+                "Circle" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle(),
+                "Rectangle" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle(),
+                _ => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Shape(),
+            };
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "name", n => { Name = n.GetStringValue(); } },
+                { "TypeName", n => { TypeName = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("name", Name);
+            writer.WriteStringValue("TypeName", TypeName);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Store.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Store.verified.cs
new file mode 100644
index 0000000000..cfa383ede7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Store.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Store : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>The location property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Location { get; set; }
+#nullable restore
+#else
+        public string Location { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "id", n => { Id = n.GetIntValue(); } },
+                { "location", n => { Location = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteIntValue("id", Id);
+            writer.WriteStringValue("location", Location);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/TestResponse.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/TestResponse.verified.cs
new file mode 100644
index 0000000000..c7b2007674
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/TestResponse.verified.cs
@@ -0,0 +1,55 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class TestResponse : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The foo property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct? Foo { get; set; }
+#nullable restore
+#else
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct Foo { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestResponse();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "foo", n => { Foo = n.GetObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct>(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct.CreateFromDiscriminatorValue); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct>("foo", Foo);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/TestStruct.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/TestStruct.verified.cs
new file mode 100644
index 0000000000..0a7e06dc2c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/TestStruct.verified.cs
@@ -0,0 +1,53 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class TestStruct : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The a property</summary>
+        public int? A { get; set; }
+        /// <summary>The b property</summary>
+        public int? B { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.TestStruct();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "a", n => { A = n.GetIntValue(); } },
+                { "b", n => { B = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteIntValue("a", A);
+            writer.WriteIntValue("b", B);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Transaction.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Transaction.verified.cs
new file mode 100644
index 0000000000..6a797549af
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Models/Transaction.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Transaction : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The amount property</summary>
+        public double? Amount { get; set; }
+        /// <summary>The note property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Note { get; set; }
+#nullable restore
+#else
+        public string Note { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Transaction();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "amount", n => { Amount = n.GetDoubleValue(); } },
+                { "note", n => { Note = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteDoubleValue("amount", Amount);
+            writer.WriteStringValue("note", Note);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Orders/OrdersRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Orders/OrdersRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c07712c3b0
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Orders/OrdersRequestBuilder.verified.cs
@@ -0,0 +1,95 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \orders
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class OrdersRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders.OrdersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public OrdersRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orders", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders.OrdersRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public OrdersRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/orders", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Creates an order
+        /// </summary>
+        /// <param name="body">Binary request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task PostAsync(Stream body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task PostAsync(Stream body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            await RequestAdapter.SendNoContentAsync(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Creates an order
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Binary request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(Stream body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(Stream body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/xml");
+            requestInfo.SetStreamContent(body, "application/xml");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders.OrdersRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders.OrdersRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Orders.OrdersRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class OrdersRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Authorize/AuthorizeRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Authorize/AuthorizeRequestBuilder.verified.cs
new file mode 100644
index 0000000000..5e14cd4209
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Authorize/AuthorizeRequestBuilder.verified.cs
@@ -0,0 +1,91 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \payments\authorize
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AuthorizeRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize.AuthorizeRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AuthorizeRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments/authorize", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize.AuthorizeRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AuthorizeRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments/authorize", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="string"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<string?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PaymentRequest body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<string> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PaymentRequest body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<string>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PaymentRequest body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.PaymentRequest body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize.AuthorizeRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize.AuthorizeRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize.AuthorizeRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class AuthorizeRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Item/Cancel/CancelRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Item/Cancel/CancelRequestBuilder.verified.cs
new file mode 100644
index 0000000000..4e55c1dffb
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Item/Cancel/CancelRequestBuilder.verified.cs
@@ -0,0 +1,84 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \payments\{paymentId}\cancel
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class CancelRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel.CancelRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CancelRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments/{paymentId}/cancel", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel.CancelRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public CancelRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments/{paymentId}/cancel", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PutAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PutAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToPutRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPutRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPutRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.PUT, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel.CancelRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel.CancelRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel.CancelRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class CancelRequestBuilderPutRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Item/WithPaymentItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Item/WithPaymentItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..9771fe9316
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/Item/WithPaymentItemRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \payments\{paymentId}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WithPaymentItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The cancel property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel.CancelRequestBuilder Cancel
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.Cancel.CancelRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.WithPaymentItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithPaymentItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments/{paymentId}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.WithPaymentItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WithPaymentItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments/{paymentId}", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/PaymentsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/PaymentsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..6b6d77cb4b
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Payments/PaymentsRequestBuilder.verified.cs
@@ -0,0 +1,54 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \payments
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class PaymentsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The authorize property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize.AuthorizeRequestBuilder Authorize
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Authorize.AuthorizeRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.payments.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.WithPaymentItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.WithPaymentItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("paymentId", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.Item.WithPaymentItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.PaymentsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PaymentsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Payments.PaymentsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PaymentsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/payments", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/All/AllRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/All/AllRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c31d2364aa
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/All/AllRequestBuilder.verified.cs
@@ -0,0 +1,93 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products\all
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AllRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All.AllRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AllRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/all", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All.AllRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AllRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/all", rawUrl)
+        {
+        }
+        /// <summary>
+        /// ```{  &quot;Id&quot;:1,  &quot;Description&quot;:&quot;&quot;,  &quot;Status&quot;: 0,  &quot;Status2&quot;: 1}            ```
+        /// </summary>
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <summary>
+        /// ```{  &quot;Id&quot;:1,  &quot;Description&quot;:&quot;&quot;,  &quot;Status&quot;: 0,  &quot;Status2&quot;: 1}            ```
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All.AllRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All.AllRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All.AllRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class AllRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/Item/ProductsItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/Item/ProductsItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..03162fda40
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/Item/ProductsItemRequestBuilder.verified.cs
@@ -0,0 +1,234 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/{id}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products/{id}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Deletes a specific product
+        /// </summary>
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Only provided properties will be updated,                    other remain unchanged.Identifier must be non-default valueBody must be specified
+        /// </summary>
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PatchAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PatchAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPatchRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Updates all properties of a specific product
+        /// </summary>
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">Represents a product</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PutAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PutAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPutRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Deletes a specific product
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Only provided properties will be updated,                    other remain unchanged.Identifier must be non-default valueBody must be specified
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPatchRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPatchRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PATCH, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Updates all properties of a specific product
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents a product</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPutRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPutRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PUT, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderPatchRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderPutRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/Item/ProductsPatchRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/Item/ProductsPatchRequestBody.verified.cs
new file mode 100644
index 0000000000..aa13c65c65
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/Item/ProductsPatchRequestBody.verified.cs
@@ -0,0 +1,55 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class ProductsPatchRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody"/> and sets the default values.
+        /// </summary>
+        public ProductsPatchRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsPatchRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..af6b4fb2b5
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,192 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The all property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All.AllRequestBuilder All
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.All.AllRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.products.item collection</summary>
+        /// <param name="position">The product id</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.products.item collection</summary>
+        /// <param name="position">The product id</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products{?kw*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/products{?kw*}", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Searches the collection of products by description key words
+        /// </summary>
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <summary>
+        /// ## Heading 1    POST /products    {        &quot;id&quot;: &quot;123&quot;,        &quot;description&quot;: &quot;Some product&quot;    }
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="body">Represents a product</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Searches the collection of products by description key words
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// ## Heading 1    POST /products    {        &quot;id&quot;: &quot;123&quot;,        &quot;description&quot;: &quot;Some product&quot;    }
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">Represents a product</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Searches the collection of products by description key words
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetQueryParameters 
+        {
+            /// <summary>A list of search terms</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("kw")]
+            public string? Kw { get; set; }
+#nullable restore
+#else
+            [QueryParameter("kw")]
+            public string Kw { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Promotions/PromotionsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Promotions/PromotionsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..c36d7d2e82
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Promotions/PromotionsRequestBuilder.verified.cs
@@ -0,0 +1,87 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \promotions
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class PromotionsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions.PromotionsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PromotionsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/promotions", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions.PromotionsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public PromotionsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/promotions", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion>?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion>> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Promotion.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions.PromotionsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions.PromotionsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Promotions.PromotionsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class PromotionsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Registrations/RegistrationsPostRequestBody.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Registrations/RegistrationsPostRequestBody.verified.cs
new file mode 100644
index 0000000000..820571787f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Registrations/RegistrationsPostRequestBody.verified.cs
@@ -0,0 +1,95 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class RegistrationsPostRequestBody : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>Description for file</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public byte[]? FormFile { get; set; }
+#nullable restore
+#else
+        public byte[] FormFile { get; set; }
+#endif
+        /// <summary>Summary for Name</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Name { get; set; }
+#nullable restore
+#else
+        public string Name { get; set; }
+#endif
+        /// <summary>Summary for PhoneNumbers</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public List<int?>? PhoneNumbers { get; set; }
+#nullable restore
+#else
+        public List<int?> PhoneNumbers { get; set; }
+#endif
+        /// <summary>Description for Text</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Text { get; set; }
+#nullable restore
+#else
+        public string Text { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody"/> and sets the default values.
+        /// </summary>
+        public RegistrationsPostRequestBody()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "formFile", n => { FormFile = n.GetByteArrayValue(); } },
+                { "name", n => { Name = n.GetStringValue(); } },
+                { "phoneNumbers", n => { PhoneNumbers = n.GetCollectionOfPrimitiveValues<int?>()?.AsList(); } },
+                { "text", n => { Text = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteByteArrayValue("formFile", FormFile);
+            writer.WriteStringValue("name", Name);
+            writer.WriteCollectionOfPrimitiveValues<int?>("phoneNumbers", PhoneNumbers);
+            writer.WriteStringValue("text", Text);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Registrations/RegistrationsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Registrations/RegistrationsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..913425d3b7
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Registrations/RegistrationsRequestBuilder.verified.cs
@@ -0,0 +1,95 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \registrations
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class RegistrationsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RegistrationsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/registrations", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RegistrationsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/registrations", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Form parameters with description
+        /// </summary>
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Form parameters with description
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/x-www-form-urlencoded", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Registrations.RegistrationsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class RegistrationsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/RegistrationsWithEnumParameter/RegistrationsWithEnumParameterRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/RegistrationsWithEnumParameter/RegistrationsWithEnumParameterRequestBuilder.verified.cs
new file mode 100644
index 0000000000..3ea9bb3193
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/RegistrationsWithEnumParameter/RegistrationsWithEnumParameterRequestBuilder.verified.cs
@@ -0,0 +1,95 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \registrationsWithEnumParameter
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class RegistrationsWithEnumParameterRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter.RegistrationsWithEnumParameterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RegistrationsWithEnumParameterRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/registrationsWithEnumParameter", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter.RegistrationsWithEnumParameterRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RegistrationsWithEnumParameterRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/registrationsWithEnumParameter", rawUrl)
+        {
+        }
+        /// <summary>
+        /// Form parameters with description
+        /// </summary>
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Form parameters with description
+        /// </summary>
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter.RegistrationsWithEnumParameterRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter.RegistrationsWithEnumParameterRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithEnumParameter.RegistrationsWithEnumParameterRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class RegistrationsWithEnumParameterRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/RegistrationsWithIgnoreProperties/RegistrationsWithIgnorePropertiesRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/RegistrationsWithIgnoreProperties/RegistrationsWithIgnorePropertiesRequestBuilder.verified.cs
new file mode 100644
index 0000000000..33dda59d28
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/RegistrationsWithIgnoreProperties/RegistrationsWithIgnorePropertiesRequestBuilder.verified.cs
@@ -0,0 +1,89 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \registrationsWithIgnoreProperties
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class RegistrationsWithIgnorePropertiesRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties.RegistrationsWithIgnorePropertiesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RegistrationsWithIgnorePropertiesRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/registrationsWithIgnoreProperties", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties.RegistrationsWithIgnorePropertiesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RegistrationsWithIgnorePropertiesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/registrationsWithIgnoreProperties", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(MultipartBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "multipart/form-data", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties.RegistrationsWithIgnorePropertiesRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties.RegistrationsWithIgnorePropertiesRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.RegistrationsWithIgnoreProperties.RegistrationsWithIgnorePropertiesRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class RegistrationsWithIgnorePropertiesRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Shapes/ShapesRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Shapes/ShapesRequestBuilder.verified.cs
new file mode 100644
index 0000000000..bdabf09ab1
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Shapes/ShapesRequestBuilder.verified.cs
@@ -0,0 +1,166 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \shapes
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ShapesRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ShapesRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/shapes", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ShapesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/shapes", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder.ShapesPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder.ShapesPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder.ShapesPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder.ShapesPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Composed type wrapper for classes <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle"/>, <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle"/>
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ShapesPostRequestBody : IComposedTypeWrapper, IParsable
+        {
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle? Circle { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle Circle { get; set; }
+#endif
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle? Rectangle { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle Rectangle { get; set; }
+#endif
+            /// <summary>
+            /// Creates a new instance of the appropriate class based on discriminator value
+            /// </summary>
+            /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder.ShapesPostRequestBody"/></returns>
+            /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+            public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder.ShapesPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+            {
+                if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+                var mappingValue = parseNode.GetChildNode("TypeName")?.GetStringValue();
+                var result = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Shapes.ShapesRequestBuilder.ShapesPostRequestBody();
+                if("Circle".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.Circle = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle();
+                }
+                else if("Rectangle".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.Rectangle = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle();
+                }
+                return result;
+            }
+            /// <summary>
+            /// The deserialization information for the current model
+            /// </summary>
+            /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+            public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+            {
+                if(Circle != null)
+                {
+                    return Circle.GetFieldDeserializers();
+                }
+                else if(Rectangle != null)
+                {
+                    return Rectangle.GetFieldDeserializers();
+                }
+                return new Dictionary<string, Action<IParseNode>>();
+            }
+            /// <summary>
+            /// Serializes information the current object
+            /// </summary>
+            /// <param name="writer">Serialization writer to use to serialize this model</param>
+            public virtual void Serialize(ISerializationWriter writer)
+            {
+                if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+                if(Circle != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Circle>(null, Circle);
+                }
+                else if(Rectangle != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Rectangle>(null, Rectangle);
+                }
+            }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ShapesRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Stores/Item/StoresItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Stores/Item/StoresItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..a4e3266e05
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Stores/Item/StoresItemRequestBuilder.verified.cs
@@ -0,0 +1,179 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \stores\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class StoresItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public StoresItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/stores/{id}{?id*,location*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public StoresItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/stores/{id}{?id*,location*}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> DeleteAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PutAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder.StoresItemRequestBuilderPutQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PutAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder.StoresItemRequestBuilderPutQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToPutRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPutRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder.StoresItemRequestBuilderPutQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPutRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder.StoresItemRequestBuilderPutQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.PUT, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class StoresItemRequestBuilderDeleteRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class StoresItemRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class StoresItemRequestBuilderPutQueryParameters 
+        #pragma warning restore CS1591
+        {
+            [QueryParameter("id")]
+            public int? Id { get; set; }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("location")]
+            public string? Location { get; set; }
+#nullable restore
+#else
+            [QueryParameter("location")]
+            public string Location { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class StoresItemRequestBuilderPutRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder.StoresItemRequestBuilderPutQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Stores/StoresRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Stores/StoresRequestBuilder.verified.cs
new file mode 100644
index 0000000000..bcdaee7f5d
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Stores/StoresRequestBuilder.verified.cs
@@ -0,0 +1,184 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \stores
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class StoresRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.stores.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.stores.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.Item.StoresItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public StoresRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/stores{?id*,location*,locations*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public StoresRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/stores{?id*,location*,locations*}", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store>?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store>> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Store.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderPostQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderPostQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToPostRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderPostQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderPostQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class StoresRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("locations")]
+            public string[]? Locations { get; set; }
+#nullable restore
+#else
+            [QueryParameter("locations")]
+            public string[] Locations { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class StoresRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderGetQueryParameters>
+        {
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class StoresRequestBuilderPostQueryParameters 
+        #pragma warning restore CS1591
+        {
+            [QueryParameter("id")]
+            public int? Id { get; set; }
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("location")]
+            public string? Location { get; set; }
+#nullable restore
+#else
+            [QueryParameter("location")]
+            public string Location { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class StoresRequestBuilderPostRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Stores.StoresRequestBuilder.StoresRequestBuilderPostQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsGetResponse.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsGetResponse.verified.cs
new file mode 100644
index 0000000000..9e2f71a79b
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsGetResponse.verified.cs
@@ -0,0 +1,55 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class UnicornsGetResponse : IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse"/> and sets the default values.
+        /// </summary>
+        public UnicornsGetResponse()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..77a44243cc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsRequestBuilder.verified.cs
@@ -0,0 +1,101 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \unicorns
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class UnicornsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public UnicornsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/unicorns", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public UnicornsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/unicorns", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse?> GetAsUnicornsGetResponseAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse> GetAsUnicornsGetResponseAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+        [Obsolete("This method is obsolete. Use GetAsUnicornsGetResponseAsync instead.")]
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse?> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse> GetAsync(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class UnicornsRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsResponse.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsResponse.verified.cs
new file mode 100644
index 0000000000..164e95fe5e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/Unicorns/UnicornsResponse.verified.cs
@@ -0,0 +1,28 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns
+{
+    [Obsolete("This class is obsolete. Use UnicornsGetResponse instead.")]
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class UnicornsResponse : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsGetResponse, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Unicorns.UnicornsResponse();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/ZipCodes/Validate/ValidateRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/ZipCodes/Validate/ValidateRequestBuilder.verified.cs
new file mode 100644
index 0000000000..12d1ad9639
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/ZipCodes/Validate/ValidateRequestBuilder.verified.cs
@@ -0,0 +1,108 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \zip-codes\validate
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ValidateRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ValidateRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/zip-codes/validate?search={search}{&zipCodes*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ValidateRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/zip-codes/validate?search={search}{&zipCodes*}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ValidateRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("search")]
+            public string? Search { get; set; }
+#nullable restore
+#else
+            [QueryParameter("search")]
+            public string Search { get; set; }
+#endif
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("zipCodes")]
+            public string[]? ZipCodes { get; set; }
+#nullable restore
+#else
+            [QueryParameter("zipCodes")]
+            public string[] ZipCodes { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ValidateRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder.ValidateRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/ZipCodes/ZipCodesRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/ZipCodes/ZipCodesRequestBuilder.verified.cs
new file mode 100644
index 0000000000..0f128af863
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_c5d548b51ce098ba/ZipCodes/ZipCodesRequestBuilder.verified.cs
@@ -0,0 +1,41 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \zip-codes
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ZipCodesRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The validate property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder Validate
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.Validate.ValidateRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.ZipCodesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ZipCodesRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/zip-codes", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.ZipCodes.ZipCodesRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ZipCodesRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/zip-codes", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_cd7f23bce481d107/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_cd7f23bce481d107/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..c38e859de8
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_cd7f23bce481d107/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,350 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = "http://localhost:57556/";
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync()
+        {
+            return ProductsAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d30b8d492860d9c9/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d30b8d492860d9c9/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..bcf2b1b61e
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d30b8d492860d9c9/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,436 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task EnumAsync(LogLevel? logLevel)
+        {
+            return EnumAsync(logLevel, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task EnumAsync(LogLevel? logLevel, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/Enum"
+                    urlBuilder_.Append("api/Enum");
+                    urlBuilder_.Append('?');
+                    if (logLevel != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("logLevel")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(logLevel, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task RequiredEnumAsync(LogLevel logLevel)
+        {
+            return RequiredEnumAsync(logLevel, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task RequiredEnumAsync(LogLevel logLevel, System.Threading.CancellationToken cancellationToken)
+        {
+            if (logLevel == null)
+                throw new System.ArgumentNullException("logLevel");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "api/RequiredEnum"
+                    urlBuilder_.Append("api/RequiredEnum");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("logLevel")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(logLevel, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public enum LogLevel
+    {
+
+        _0 = 0,
+
+        _1 = 1,
+
+        _2 = 2,
+
+        _3 = 3,
+
+        _4 = 4,
+
+        _5 = 5,
+
+        _6 = 6,
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/ApiRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/ApiRequestBuilder.verified.cs
new file mode 100644
index 0000000000..26c519e671
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/ApiRequestBuilder.verified.cs
@@ -0,0 +1,47 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ApiRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>The Enum property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder Enum
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The RequiredEnum property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder RequiredEnum
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ApiRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api", rawUrl)
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/EnumNamespace/EnumRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/EnumNamespace/EnumRequestBuilder.verified.cs
new file mode 100644
index 0000000000..a214bf9719
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/EnumNamespace/EnumRequestBuilder.verified.cs
@@ -0,0 +1,99 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\Enum
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class EnumRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public EnumRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/Enum{?logLevel*}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public EnumRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/Enum{?logLevel*}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder.EnumRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder.EnumRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder.EnumRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder.EnumRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class EnumRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("logLevel")]
+            public string? LogLevel { get; set; }
+#nullable restore
+#else
+            [QueryParameter("logLevel")]
+            public string LogLevel { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class EnumRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.EnumNamespace.EnumRequestBuilder.EnumRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/RequiredEnum/RequiredEnumRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/RequiredEnum/RequiredEnumRequestBuilder.verified.cs
new file mode 100644
index 0000000000..3dfdde81dd
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/Api/RequiredEnum/RequiredEnumRequestBuilder.verified.cs
@@ -0,0 +1,99 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \api\RequiredEnum
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class RequiredEnumRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RequiredEnumRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/RequiredEnum?logLevel={logLevel}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public RequiredEnumRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/api/RequiredEnum?logLevel={logLevel}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder.RequiredEnumRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder.RequiredEnumRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder.RequiredEnumRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder.RequiredEnumRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class RequiredEnumRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("logLevel")]
+            public string? LogLevel { get; set; }
+#nullable restore
+#else
+            [QueryParameter("logLevel")]
+            public string LogLevel { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class RequiredEnumRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.RequiredEnum.RequiredEnumRequestBuilder.RequiredEnumRequestBuilderGetQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..f1c91cb638
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_d8671235c41dfbe0/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The api property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder Api
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Api.ApiRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_dde2647b4ed96daa/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_dde2647b4ed96daa/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..fd39c6bc34
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_dde2647b4ed96daa/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,645 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = "/resource-server";
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAllAsync()
+        {
+            return ProductsAllAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAllAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 401)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Unauthorized", status_, responseText_, headers_, null);
+                        }
+                        else
+                        if (status_ == 403)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Forbidden", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task ProductsPOSTAsync(Product body)
+        {
+            return ProductsPOSTAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task ProductsPOSTAsync(Product body, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        if (status_ == 401)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Unauthorized", status_, responseText_, headers_, null);
+                        }
+                        else
+                        if (status_ == 403)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Forbidden", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> ProductsGETAsync(int id)
+        {
+            return ProductsGETAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> ProductsGETAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products/{id}"
+                    urlBuilder_.Append("products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        if (status_ == 401)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Unauthorized", status_, responseText_, headers_, null);
+                        }
+                        else
+                        if (status_ == 403)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Forbidden", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task ProductsDELETEAsync(int id)
+        {
+            return ProductsDELETEAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task ProductsDELETEAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("DELETE");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products/{id}"
+                    urlBuilder_.Append("products/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        if (status_ == 401)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Unauthorized", status_, responseText_, headers_, null);
+                        }
+                        else
+                        if (status_ == 403)
+                        {
+                            string responseText_ = ( response_.Content == null ) ? string.Empty : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("Forbidden", status_, responseText_, headers_, null);
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("serialNo", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string SerialNo { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("status", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public ProductStatus Status { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public enum ProductStatus
+    {
+
+        _0 = 0,
+
+        _1 = 1,
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Animals/AnimalsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Animals/AnimalsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..7347f6f205
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Animals/AnimalsRequestBuilder.verified.cs
@@ -0,0 +1,185 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \Animals
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class AnimalsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AnimalsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Animals", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public AnimalsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Animals", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder.AnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder.AnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder.AnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder.AnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Composed type wrapper for classes <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal"/>, <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat"/>, <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog"/>
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class AnimalsPostRequestBody : IComposedTypeWrapper, IParsable
+        {
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal? Animal { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal Animal { get; set; }
+#endif
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat? Cat { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat Cat { get; set; }
+#endif
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog? Dog { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog Dog { get; set; }
+#endif
+            /// <summary>
+            /// Creates a new instance of the appropriate class based on discriminator value
+            /// </summary>
+            /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder.AnimalsPostRequestBody"/></returns>
+            /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+            public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder.AnimalsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+            {
+                if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+                var mappingValue = parseNode.GetChildNode("animalType")?.GetStringValue();
+                var result = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder.AnimalsPostRequestBody();
+                if("".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.Animal = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal();
+                }
+                else if("Cat".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.Cat = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat();
+                }
+                else if("Dog".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.Dog = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog();
+                }
+                return result;
+            }
+            /// <summary>
+            /// The deserialization information for the current model
+            /// </summary>
+            /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+            public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+            {
+                if(Animal != null)
+                {
+                    return Animal.GetFieldDeserializers();
+                }
+                else if(Cat != null)
+                {
+                    return Cat.GetFieldDeserializers();
+                }
+                else if(Dog != null)
+                {
+                    return Dog.GetFieldDeserializers();
+                }
+                return new Dictionary<string, Action<IParseNode>>();
+            }
+            /// <summary>
+            /// Serializes information the current object
+            /// </summary>
+            /// <param name="writer">Serialization writer to use to serialize this model</param>
+            public virtual void Serialize(ISerializationWriter writer)
+            {
+                if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+                if(Animal != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal>(null, Animal);
+                }
+                else if(Cat != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat>(null, Cat);
+                }
+                else if(Dog != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog>(null, Dog);
+                }
+            }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class AnimalsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..1d33d61c09
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,61 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The Animals property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder Animals
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Animals.AnimalsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The SecondLevel property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel.SecondLevelRequestBuilder SecondLevel
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel.SecondLevelRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The SystemTextJsonAnimals property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder SystemTextJsonAnimals
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>The SystemTextJsonDefaultDiscriminatorAnimals property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder SystemTextJsonDefaultDiscriminatorAnimals
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Animal.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Animal.verified.cs
new file mode 100644
index 0000000000..3b792099e5
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Animal.verified.cs
@@ -0,0 +1,55 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Animal : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The animalType property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AnimalType? AnimalType { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            var mappingValue = parseNode.GetChildNode("animalType")?.GetStringValue();
+            return mappingValue switch
+            {
+                "Cat" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat(),
+                "Dog" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog(),
+                _ => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal(),
+            };
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "animalType", n => { AnimalType = n.GetEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AnimalType>(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteEnumValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.AnimalType>("animalType", AnimalType);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/AnimalType.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/AnimalType.verified.cs
new file mode 100644
index 0000000000..32e4d2d2ba
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/AnimalType.verified.cs
@@ -0,0 +1,20 @@
+// <auto-generated/>
+using System.Runtime.Serialization;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public enum AnimalType
+    #pragma warning restore CS1591
+    {
+        [EnumMember(Value = "Cat")]
+        #pragma warning disable CS1591
+        Cat,
+        #pragma warning restore CS1591
+        [EnumMember(Value = "Dog")]
+        #pragma warning disable CS1591
+        Dog,
+        #pragma warning restore CS1591
+    }
+}
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/BaseType.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/BaseType.verified.cs
new file mode 100644
index 0000000000..6aecf467ed
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/BaseType.verified.cs
@@ -0,0 +1,70 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class BaseType : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The discriminator property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Discriminator { get; set; }
+#nullable restore
+#else
+        public string Discriminator { get; set; }
+#endif
+        /// <summary>The property property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Property { get; set; }
+#nullable restore
+#else
+        public string Property { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.BaseType"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.BaseType CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            var mappingValue = parseNode.GetChildNode("discriminator")?.GetStringValue();
+            return mappingValue switch
+            {
+                "SubSubType" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType(),
+                _ => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.BaseType(),
+            };
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "discriminator", n => { Discriminator = n.GetStringValue(); } },
+                { "property", n => { Property = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("discriminator", Discriminator);
+            writer.WriteStringValue("property", Property);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Cat.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Cat.verified.cs
new file mode 100644
index 0000000000..b543db143c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Cat.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Cat : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The catSpecificProperty property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CatSpecificProperty { get; set; }
+#nullable restore
+#else
+        public string CatSpecificProperty { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat"/> and sets the default values.
+        /// </summary>
+        public Cat() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Cat();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "catSpecificProperty", n => { CatSpecificProperty = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("catSpecificProperty", CatSpecificProperty);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Dog.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Dog.verified.cs
new file mode 100644
index 0000000000..27ded33c37
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/Dog.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Dog : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Animal, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The dogSpecificProperty property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? DogSpecificProperty { get; set; }
+#nullable restore
+#else
+        public string DogSpecificProperty { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog"/> and sets the default values.
+        /// </summary>
+        public Dog() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Dog();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "dogSpecificProperty", n => { DogSpecificProperty = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("dogSpecificProperty", DogSpecificProperty);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SubSubType.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SubSubType.verified.cs
new file mode 100644
index 0000000000..1f0e7e3261
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SubSubType.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class SubSubType : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.BaseType, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The property2 property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Property2 { get; set; }
+#nullable restore
+#else
+        public string Property2 { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType"/> and sets the default values.
+        /// </summary>
+        public SubSubType() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "property2", n => { Property2 = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("property2", Property2);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonAnimal.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonAnimal.verified.cs
new file mode 100644
index 0000000000..0ccd4e00ed
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonAnimal.verified.cs
@@ -0,0 +1,61 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class SystemTextJsonAnimal : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The animalType property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? AnimalType { get; set; }
+#nullable restore
+#else
+        public string AnimalType { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            var mappingValue = parseNode.GetChildNode("animalType")?.GetStringValue();
+            return mappingValue switch
+            {
+                "Cat" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat(),
+                "Dog" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog(),
+                _ => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal(),
+            };
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "animalType", n => { AnimalType = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("animalType", AnimalType);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonCat.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonCat.verified.cs
new file mode 100644
index 0000000000..487bfccb5c
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonCat.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class SystemTextJsonCat : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The catSpecificProperty property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CatSpecificProperty { get; set; }
+#nullable restore
+#else
+        public string CatSpecificProperty { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat"/> and sets the default values.
+        /// </summary>
+        public SystemTextJsonCat() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "catSpecificProperty", n => { CatSpecificProperty = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("catSpecificProperty", CatSpecificProperty);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorAnimal.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorAnimal.verified.cs
new file mode 100644
index 0000000000..5be70bae09
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorAnimal.verified.cs
@@ -0,0 +1,71 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class SystemTextJsonDefaultDiscriminatorAnimal : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The animalType property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? AnimalType { get; set; }
+#nullable restore
+#else
+        public string AnimalType { get; set; }
+#endif
+        /// <summary>The Type property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Type { get; set; }
+#nullable restore
+#else
+        public string Type { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            var mappingValue = parseNode.GetChildNode("$type")?.GetStringValue();
+            return mappingValue switch
+            {
+                "Cat" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat(),
+                "Dog" => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog(),
+                _ => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal(),
+            };
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "animalType", n => { AnimalType = n.GetStringValue(); } },
+                { "$type", n => { Type = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("animalType", AnimalType);
+            writer.WriteStringValue("$type", Type);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorCat.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorCat.verified.cs
new file mode 100644
index 0000000000..e90be4a5fb
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorCat.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class SystemTextJsonDefaultDiscriminatorCat : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The catSpecificProperty property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? CatSpecificProperty { get; set; }
+#nullable restore
+#else
+        public string CatSpecificProperty { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat"/> and sets the default values.
+        /// </summary>
+        public SystemTextJsonDefaultDiscriminatorCat() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "catSpecificProperty", n => { CatSpecificProperty = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("catSpecificProperty", CatSpecificProperty);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorDog.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorDog.verified.cs
new file mode 100644
index 0000000000..fe72a52723
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDefaultDiscriminatorDog.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class SystemTextJsonDefaultDiscriminatorDog : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The dogSpecificProperty property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? DogSpecificProperty { get; set; }
+#nullable restore
+#else
+        public string DogSpecificProperty { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog"/> and sets the default values.
+        /// </summary>
+        public SystemTextJsonDefaultDiscriminatorDog() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "dogSpecificProperty", n => { DogSpecificProperty = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("dogSpecificProperty", DogSpecificProperty);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDog.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDog.verified.cs
new file mode 100644
index 0000000000..75bcc5d387
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/Models/SystemTextJsonDog.verified.cs
@@ -0,0 +1,66 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class SystemTextJsonDog : global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal, IAdditionalDataHolder, IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.</summary>
+        public IDictionary<string, object> AdditionalData { get; set; }
+        /// <summary>The dogSpecificProperty property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? DogSpecificProperty { get; set; }
+#nullable restore
+#else
+        public string DogSpecificProperty { get; set; }
+#endif
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog"/> and sets the default values.
+        /// </summary>
+        public SystemTextJsonDog() : base()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public override IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>(base.GetFieldDeserializers())
+            {
+                { "dogSpecificProperty", n => { DogSpecificProperty = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public override void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            base.Serialize(writer);
+            writer.WriteStringValue("dogSpecificProperty", DogSpecificProperty);
+            writer.WriteAdditionalData(AdditionalData);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SecondLevel/SecondLevelRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SecondLevel/SecondLevelRequestBuilder.verified.cs
new file mode 100644
index 0000000000..46f7836857
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SecondLevel/SecondLevelRequestBuilder.verified.cs
@@ -0,0 +1,91 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \SecondLevel
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class SecondLevelRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel.SecondLevelRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SecondLevelRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/SecondLevel", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel.SecondLevelRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SecondLevelRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/SecondLevel", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SubSubType body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "application/json");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel.SecondLevelRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel.SecondLevelRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SecondLevel.SecondLevelRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SecondLevelRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SystemTextJsonAnimals/SystemTextJsonAnimalsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SystemTextJsonAnimals/SystemTextJsonAnimalsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..e2ae00df7f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SystemTextJsonAnimals/SystemTextJsonAnimalsRequestBuilder.verified.cs
@@ -0,0 +1,185 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \SystemTextJsonAnimals
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class SystemTextJsonAnimalsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SystemTextJsonAnimalsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/SystemTextJsonAnimals", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SystemTextJsonAnimalsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/SystemTextJsonAnimals", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder.SystemTextJsonAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder.SystemTextJsonAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder.SystemTextJsonAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder.SystemTextJsonAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Composed type wrapper for classes <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal"/>, <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat"/>, <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog"/>
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SystemTextJsonAnimalsPostRequestBody : IComposedTypeWrapper, IParsable
+        {
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal? SystemTextJsonAnimal { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal SystemTextJsonAnimal { get; set; }
+#endif
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat? SystemTextJsonCat { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat SystemTextJsonCat { get; set; }
+#endif
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog? SystemTextJsonDog { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog SystemTextJsonDog { get; set; }
+#endif
+            /// <summary>
+            /// Creates a new instance of the appropriate class based on discriminator value
+            /// </summary>
+            /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder.SystemTextJsonAnimalsPostRequestBody"/></returns>
+            /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+            public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder.SystemTextJsonAnimalsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+            {
+                if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+                var mappingValue = parseNode.GetChildNode("animalType")?.GetStringValue();
+                var result = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonAnimals.SystemTextJsonAnimalsRequestBuilder.SystemTextJsonAnimalsPostRequestBody();
+                if("".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.SystemTextJsonAnimal = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal();
+                }
+                else if("Cat".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.SystemTextJsonCat = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat();
+                }
+                else if("Dog".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.SystemTextJsonDog = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog();
+                }
+                return result;
+            }
+            /// <summary>
+            /// The deserialization information for the current model
+            /// </summary>
+            /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+            public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+            {
+                if(SystemTextJsonAnimal != null)
+                {
+                    return SystemTextJsonAnimal.GetFieldDeserializers();
+                }
+                else if(SystemTextJsonCat != null)
+                {
+                    return SystemTextJsonCat.GetFieldDeserializers();
+                }
+                else if(SystemTextJsonDog != null)
+                {
+                    return SystemTextJsonDog.GetFieldDeserializers();
+                }
+                return new Dictionary<string, Action<IParseNode>>();
+            }
+            /// <summary>
+            /// Serializes information the current object
+            /// </summary>
+            /// <param name="writer">Serialization writer to use to serialize this model</param>
+            public virtual void Serialize(ISerializationWriter writer)
+            {
+                if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+                if(SystemTextJsonAnimal != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonAnimal>(null, SystemTextJsonAnimal);
+                }
+                else if(SystemTextJsonCat != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonCat>(null, SystemTextJsonCat);
+                }
+                else if(SystemTextJsonDog != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDog>(null, SystemTextJsonDog);
+                }
+            }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SystemTextJsonAnimalsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SystemTextJsonDefaultDiscriminatorAnimals/SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SystemTextJsonDefaultDiscriminatorAnimals/SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..004c2186fc
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_e697641459ecbe2d/SystemTextJsonDefaultDiscriminatorAnimals/SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.verified.cs
@@ -0,0 +1,185 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \SystemTextJsonDefaultDiscriminatorAnimals
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/SystemTextJsonDefaultDiscriminatorAnimals", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/SystemTextJsonDefaultDiscriminatorAnimals", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Composed type wrapper for classes <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal"/>, <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat"/>, <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog"/>
+        /// </summary>
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody : IComposedTypeWrapper, IParsable
+        {
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal? SystemTextJsonDefaultDiscriminatorAnimal { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal SystemTextJsonDefaultDiscriminatorAnimal { get; set; }
+#endif
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat? SystemTextJsonDefaultDiscriminatorCat { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat SystemTextJsonDefaultDiscriminatorCat { get; set; }
+#endif
+            /// <summary>Composed type representation for type <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog"/></summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog? SystemTextJsonDefaultDiscriminatorDog { get; set; }
+#nullable restore
+#else
+            public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog SystemTextJsonDefaultDiscriminatorDog { get; set; }
+#endif
+            /// <summary>
+            /// Creates a new instance of the appropriate class based on discriminator value
+            /// </summary>
+            /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody"/></returns>
+            /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+            public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody CreateFromDiscriminatorValue(IParseNode parseNode)
+            {
+                if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+                var mappingValue = parseNode.GetChildNode("$type")?.GetStringValue();
+                var result = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.SystemTextJsonDefaultDiscriminatorAnimals.SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilder.SystemTextJsonDefaultDiscriminatorAnimalsPostRequestBody();
+                if("".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.SystemTextJsonDefaultDiscriminatorAnimal = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal();
+                }
+                else if("Cat".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.SystemTextJsonDefaultDiscriminatorCat = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat();
+                }
+                else if("Dog".Equals(mappingValue, StringComparison.OrdinalIgnoreCase))
+                {
+                    result.SystemTextJsonDefaultDiscriminatorDog = new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog();
+                }
+                return result;
+            }
+            /// <summary>
+            /// The deserialization information for the current model
+            /// </summary>
+            /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+            public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+            {
+                if(SystemTextJsonDefaultDiscriminatorAnimal != null)
+                {
+                    return SystemTextJsonDefaultDiscriminatorAnimal.GetFieldDeserializers();
+                }
+                else if(SystemTextJsonDefaultDiscriminatorCat != null)
+                {
+                    return SystemTextJsonDefaultDiscriminatorCat.GetFieldDeserializers();
+                }
+                else if(SystemTextJsonDefaultDiscriminatorDog != null)
+                {
+                    return SystemTextJsonDefaultDiscriminatorDog.GetFieldDeserializers();
+                }
+                return new Dictionary<string, Action<IParseNode>>();
+            }
+            /// <summary>
+            /// Serializes information the current object
+            /// </summary>
+            /// <param name="writer">Serialization writer to use to serialize this model</param>
+            public virtual void Serialize(ISerializationWriter writer)
+            {
+                if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+                if(SystemTextJsonDefaultDiscriminatorAnimal != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorAnimal>(null, SystemTextJsonDefaultDiscriminatorAnimal);
+                }
+                else if(SystemTextJsonDefaultDiscriminatorCat != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorCat>(null, SystemTextJsonDefaultDiscriminatorCat);
+                }
+                else if(SystemTextJsonDefaultDiscriminatorDog != null)
+                {
+                    writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.SystemTextJsonDefaultDiscriminatorDog>(null, SystemTextJsonDefaultDiscriminatorDog);
+                }
+            }
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class SystemTextJsonDefaultDiscriminatorAnimalsRequestBuilderPostRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..c672df5e27
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The Products property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder Products
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Models/Product.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Models/Product.verified.cs
new file mode 100644
index 0000000000..97de045e50
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Models/Product.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Product : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The description property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Description { get; set; }
+#nullable restore
+#else
+        public string Description { get; set; }
+#endif
+        /// <summary>The id property</summary>
+        public int? Id { get; set; }
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "description", n => { Description = n.GetStringValue(); } },
+                { "id", n => { Id = n.GetIntValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("description", Description);
+            writer.WriteIntValue("id", Id);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Products/Item/ProductsItemRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Products/Item/ProductsItemRequestBuilder.verified.cs
new file mode 100644
index 0000000000..a1092fb977
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Products/Item/ProductsItemRequestBuilder.verified.cs
@@ -0,0 +1,158 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \Products\{id}
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsItemRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Products/{id}?api-version={api%2Dversion}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Products/{id}?api-version={api%2Dversion}", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> DeleteAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderDeleteQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> DeleteAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderDeleteQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToDeleteRequestInformation(requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> PutAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderPutQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> PutAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderPutQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPutRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderDeleteQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToDeleteRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderDeleteQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.DELETE, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPutRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderPutQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPutRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderPutQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.PUT, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ProductsItemRequestBuilderDeleteQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("api%2Dversion")]
+            public string? ApiVersion { get; set; }
+#nullable restore
+#else
+            [QueryParameter("api%2Dversion")]
+            public string ApiVersion { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderDeleteRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderDeleteQueryParameters>
+        {
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ProductsItemRequestBuilderPutQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("api%2Dversion")]
+            public string? ApiVersion { get; set; }
+#nullable restore
+#else
+            [QueryParameter("api%2Dversion")]
+            public string ApiVersion { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsItemRequestBuilderPutRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder.ProductsItemRequestBuilderPutQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Products/ProductsRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Products/ProductsRequestBuilder.verified.cs
new file mode 100644
index 0000000000..5048027f5a
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_ef221d99380f04b3/Products/ProductsRequestBuilder.verified.cs
@@ -0,0 +1,187 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \Products
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class ProductsRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[int position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>Gets an item from the Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.item collection</summary>
+        /// <param name="position">Unique identifier of the item</param>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder"/></returns>
+        [Obsolete("This indexer is deprecated and will be removed in the next major version. Use the one with the typed parameter instead.")]
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder this[string position]
+        {
+            get
+            {
+                var urlTplParams = new Dictionary<string, object>(PathParameters);
+                if (!string.IsNullOrWhiteSpace(position)) urlTplParams.Add("id", position);
+                return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.Item.ProductsItemRequestBuilder(urlTplParams, RequestAdapter);
+            }
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Products?api-version={api%2Dversion}", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public ProductsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/Products?api-version={api%2Dversion}", rawUrl)
+        {
+        }
+        /// <returns>A List&lt;global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product&gt;</returns>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>?> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<List<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>> GetAsync(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            var requestInfo = ToGetRequestInformation(requestConfiguration);
+            var collectionResult = await RequestAdapter.SendCollectionAsync<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product>(requestInfo, global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product.CreateFromDiscriminatorValue, default, cancellationToken).ConfigureAwait(false);
+            return collectionResult?.AsList();
+        }
+        /// <returns>A <see cref="int"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderPostQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<int?> PostAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderPostQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToPostRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<int?>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            return requestInfo;
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderPostQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToPostRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Product body, Action<RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderPostQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.Headers.TryAdd("Accept", "text/plain;q=0.9");
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder(rawUrl, RequestAdapter);
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ProductsRequestBuilderGetQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("api%2Dversion")]
+            public string? ApiVersion { get; set; }
+#nullable restore
+#else
+            [QueryParameter("api%2Dversion")]
+            public string ApiVersion { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderGetRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderGetQueryParameters>
+        {
+        }
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        #pragma warning disable CS1591
+        public partial class ProductsRequestBuilderPostQueryParameters 
+        #pragma warning restore CS1591
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+            [QueryParameter("api%2Dversion")]
+            public string? ApiVersion { get; set; }
+#nullable restore
+#else
+            [QueryParameter("api%2Dversion")]
+            public string ApiVersion { get; set; }
+#endif
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class ProductsRequestBuilderPostRequestConfiguration : RequestConfiguration<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Products.ProductsRequestBuilder.ProductsRequestBuilderPostQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f2a4d1a266495eca/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f2a4d1a266495eca/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..795937b1e2
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f2a4d1a266495eca/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,2347 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <summary>
+        /// CreateFruit
+        /// </summary>
+        /// <remarks>
+        /// Create a fruit
+        /// </remarks>
+        /// <param name="id">The id of the fruit that will be created</param>
+        /// <param name="body">Description for Body</param>
+        /// <returns>Description for response</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Fruit> FruitAsync(string id, Fruit body)
+        {
+            return FruitAsync(id, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// CreateFruit
+        /// </summary>
+        /// <remarks>
+        /// Create a fruit
+        /// </remarks>
+        /// <param name="id">The id of the fruit that will be created</param>
+        /// <param name="body">Description for Body</param>
+        /// <returns>Description for response</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Fruit> FruitAsync(string id, Fruit body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/fruit/{id}"
+                    urlBuilder_.Append("annotations/fruit/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Fruit>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="firstName">Description for FirstName</param>
+        /// <param name="lastName">Description for LastName</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> SingleFormAsync(string firstName, string lastName)
+        {
+            return SingleFormAsync(firstName, lastName, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="firstName">Description for FirstName</param>
+        /// <param name="lastName">Description for LastName</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> SingleFormAsync(string firstName, string lastName, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (firstName != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("firstName", ConvertToString(firstName, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (lastName != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("lastName", ConvertToString(lastName, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/singleForm"
+                    urlBuilder_.Append("annotations/singleForm");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="street">Description for Street</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> MultipleFormsAsync(string street, string city, string state, string zipCode)
+        {
+            return MultipleFormsAsync(street, city, state, zipCode, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="street">Description for Street</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> MultipleFormsAsync(string street, string city, string state, string zipCode, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (street != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("street", ConvertToString(street, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (city != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("city", ConvertToString(city, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (state != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("state", ConvertToString(state, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (zipCode != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("zipCode", ConvertToString(zipCode, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/multipleForms"
+                    urlBuilder_.Append("annotations/multipleForms");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="file">Description for File</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndStringAsync(FileParameter file, string tags)
+        {
+            return IFromFileAndStringAsync(file, tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="file">Description for File</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndStringAsync(FileParameter file, string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)), "tags");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/IFromFileAndString"
+                    urlBuilder_.Append("annotations/IFromFileAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndEnumAsync(FileParameter file, DateTimeKind? dateTimeKind)
+        {
+            return IFromFileAndEnumAsync(file, dateTimeKind, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndEnumAsync(FileParameter file, DateTimeKind? dateTimeKind, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (dateTimeKind == null)
+                        throw new System.ArgumentNullException("dateTimeKind");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(dateTimeKind, System.Globalization.CultureInfo.InvariantCulture)), "dateTimeKind");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/IFromFileAndEnum"
+                    urlBuilder_.Append("annotations/IFromFileAndEnum");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromObjectAndStringAsync(string tags)
+        {
+            return IFromObjectAndStringAsync(tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromObjectAndStringAsync(string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("tags", ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/IFromObjectAndString"
+                    urlBuilder_.Append("annotations/IFromObjectAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="paramOne">Description</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<AsParametersRecord> AsParametersAsync(System.Guid? paramOne, System.Guid paramTwo, System.DateTimeOffset? paramThree, System.DateTimeOffset paramFour, System.DateTimeOffset? paramFive, System.DateTimeOffset paramSix, System.TimeSpan? paramSeven, System.TimeSpan paramEight, DateTimeKind? paramNine, DateTimeKind paramTen, double? paramEleven, double paramTwelve)
+        {
+            return AsParametersAsync(paramOne, paramTwo, paramThree, paramFour, paramFive, paramSix, paramSeven, paramEight, paramNine, paramTen, paramEleven, paramTwelve, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="paramOne">Description</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<AsParametersRecord> AsParametersAsync(System.Guid? paramOne, System.Guid paramTwo, System.DateTimeOffset? paramThree, System.DateTimeOffset paramFour, System.DateTimeOffset? paramFive, System.DateTimeOffset paramSix, System.TimeSpan? paramSeven, System.TimeSpan paramEight, DateTimeKind? paramNine, DateTimeKind paramTen, double? paramEleven, double paramTwelve, System.Threading.CancellationToken cancellationToken)
+        {
+            if (paramTwo == null)
+                throw new System.ArgumentNullException("paramTwo");
+
+            if (paramFour == null)
+                throw new System.ArgumentNullException("paramFour");
+
+            if (paramSix == null)
+                throw new System.ArgumentNullException("paramSix");
+
+            if (paramEight == null)
+                throw new System.ArgumentNullException("paramEight");
+
+            if (paramTen == null)
+                throw new System.ArgumentNullException("paramTen");
+
+            if (paramTwelve == null)
+                throw new System.ArgumentNullException("paramTwelve");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/AsParameters"
+                    urlBuilder_.Append("annotations/AsParameters");
+                    urlBuilder_.Append('?');
+                    if (paramOne != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramOne")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramOne, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramTwo")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramTwo, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramThree != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramThree")).Append('=').Append(System.Uri.EscapeDataString(paramThree.Value.ToString("s", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramFour")).Append('=').Append(System.Uri.EscapeDataString(paramFour.ToString("s", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramFive != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramFive")).Append('=').Append(System.Uri.EscapeDataString(paramFive.Value.ToString("yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramSix")).Append('=').Append(System.Uri.EscapeDataString(paramSix.ToString("yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramSeven != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramSeven")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramSeven, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramEight")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramEight, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramNine != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramNine")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramNine, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramTen")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramTen, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramEleven != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramEleven")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramEleven, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramTwelve")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramTwelve, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<AsParametersRecord>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> TypeWithTryParseAsync(string tryParse)
+        {
+            return TypeWithTryParseAsync(tryParse, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> TypeWithTryParseAsync(string tryParse, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tryParse == null)
+                throw new System.ArgumentNullException("tryParse");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "TypeWithTryParse/{tryParse}"
+                    urlBuilder_.Append("TypeWithTryParse/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tryParse, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<WeatherForecast>> GetWeatherForecastAsync()
+        {
+            return GetWeatherForecastAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<WeatherForecast>> GetWeatherForecastAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/weatherforecast"
+                    urlBuilder_.Append("WithOpenApi/weatherforecast");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<WeatherForecast>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> MultipleForms2Async(string street, string city, string state, string zipCode)
+        {
+            return MultipleForms2Async(street, city, state, zipCode, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> MultipleForms2Async(string street, string city, string state, string zipCode, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (street != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("street", ConvertToString(street, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (city != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("city", ConvertToString(city, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (state != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("state", ConvertToString(state, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (zipCode != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("zipCode", ConvertToString(zipCode, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/multipleForms"
+                    urlBuilder_.Append("WithOpenApi/multipleForms");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAsync(string queryParameter, FileParameter file)
+        {
+            return IFromFileAsync(queryParameter, file, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAsync(string queryParameter, FileParameter file, System.Threading.CancellationToken cancellationToken)
+        {
+            if (queryParameter == null)
+                throw new System.ArgumentNullException("queryParameter");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFile"
+                    urlBuilder_.Append("WithOpenApi/IFromFile");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("queryParameter")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(queryParameter, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileCollectionAsync(System.Collections.Generic.IEnumerable<FileParameter> collection)
+        {
+            return IFromFileCollectionAsync(collection, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileCollectionAsync(System.Collections.Generic.IEnumerable<FileParameter> collection, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (collection == null)
+                        throw new System.ArgumentNullException("collection");
+                    else
+                    {
+                        foreach (var item_ in collection)
+                        {
+                            var content_collection_ = new System.Net.Http.StreamContent(item_.Data);
+                            if (!string.IsNullOrEmpty(item_.ContentType))
+                                content_collection_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(item_.ContentType);
+                            content_.Add(content_collection_, "collection", item_.FileName ?? "collection");
+                        }
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFileCollection"
+                    urlBuilder_.Append("WithOpenApi/IFromFileCollection");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromBodyAsync(OrganizationCustomExchangeRatesDto body)
+        {
+            return IFromBodyAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromBodyAsync(OrganizationCustomExchangeRatesDto body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromBody"
+                    urlBuilder_.Append("WithOpenApi/IFromBody");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndString2Async(FileParameter file, string tags)
+        {
+            return IFromFileAndString2Async(file, tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndString2Async(FileParameter file, string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)), "tags");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFileAndString"
+                    urlBuilder_.Append("WithOpenApi/IFromFileAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndEnum2Async(FileParameter file, DateTimeKind? dateTimeKind)
+        {
+            return IFromFileAndEnum2Async(file, dateTimeKind, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndEnum2Async(FileParameter file, DateTimeKind? dateTimeKind, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (dateTimeKind == null)
+                        throw new System.ArgumentNullException("dateTimeKind");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(dateTimeKind, System.Globalization.CultureInfo.InvariantCulture)), "dateTimeKind");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFileAndEnum"
+                    urlBuilder_.Append("WithOpenApi/IFromFileAndEnum");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromObjectAndString2Async(string tags)
+        {
+            return IFromObjectAndString2Async(tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromObjectAndString2Async(string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("tags", ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromObjectAndString"
+                    urlBuilder_.Append("WithOpenApi/IFromObjectAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <param name="id">The product id</param>
+        /// <returns>A Product Id</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> CarAsync(int id)
+        {
+            return CarAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <param name="id">The product id</param>
+        /// <returns>A Product Id</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> CarAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/Car/{id}"
+                    urlBuilder_.Append("XmlComments/Car/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <param name="id">Uniquely identifies the product</param>
+        /// <param name="description">Describes the product</param>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> Car2Async(int id, string description)
+        {
+            return Car2Async(id, description, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <param name="id">Uniquely identifies the product</param>
+        /// <param name="description">Describes the product</param>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> Car2Async(int id, string description, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/Car"
+                    urlBuilder_.Append("XmlComments/Car");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("Id")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (description != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("Description")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(description, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> CarWithProducesAsync(int id)
+        {
+            return CarWithProducesAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> CarWithProducesAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/CarWithProduces"
+                    urlBuilder_.Append("XmlComments/CarWithProduces");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("id")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> CarWithProducesDefaultResponseTypeAsync(int id)
+        {
+            return CarWithProducesDefaultResponseTypeAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> CarWithProducesDefaultResponseTypeAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/CarWithProducesDefaultResponseType"
+                    urlBuilder_.Append("XmlComments/CarWithProducesDefaultResponseType");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("id")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<Product>("A Product", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Address
+    {
+
+        [Newtonsoft.Json.JsonProperty("street", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Street { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("city", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string City { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("state", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string State { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("zipCode", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string ZipCode { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class AddressAnnotated
+    {
+
+        /// <summary>
+        /// Description for Street
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("street", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Street { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("city", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string City { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("state", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string State { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("zipCode", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string ZipCode { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class AsParametersRecord
+    {
+
+        [Newtonsoft.Json.JsonProperty("paramOne", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.Guid? ParamOne { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramTwo", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.Guid ParamTwo { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramThree", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset? ParamThree { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramFour", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset ParamFour { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramFive", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(DateFormatConverter))]
+        public System.DateTimeOffset? ParamFive { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramSix", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(DateFormatConverter))]
+        public System.DateTimeOffset ParamSix { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramSeven", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.TimeSpan? ParamSeven { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramEight", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.TimeSpan ParamEight { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramNine", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public DateTimeKind ParamNine { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramTen", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public DateTimeKind ParamTen { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramEleven", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public double? ParamEleven { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramTwelve", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public double ParamTwelve { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class CurrenciesRate
+    {
+
+        /// <summary>
+        /// Currency From
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("currencyFrom", Required = Newtonsoft.Json.Required.AllowNull)]
+        public string CurrencyFrom { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("currencyTo", Required = Newtonsoft.Json.Required.AllowNull)]
+        public string CurrencyTo { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("rate", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public double Rate { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public enum DateTimeKind
+    {
+
+        _0 = 0,
+
+        _1 = 1,
+
+        _2 = 2,
+
+    }
+
+    /// <summary>
+    /// Description for Schema
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Fruit
+    {
+
+        [Newtonsoft.Json.JsonProperty("name", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Name { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class OrganizationCustomExchangeRatesDto
+    {
+
+        [Newtonsoft.Json.JsonProperty("currenciesRates", Required = Newtonsoft.Json.Required.AllowNull)]
+        public System.Collections.Generic.ICollection<CurrenciesRate> CurrenciesRates { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("isUpdated", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public bool IsUpdated { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Person
+    {
+
+        [Newtonsoft.Json.JsonProperty("firstName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string FirstName { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("lastName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string LastName { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class PersonAnnotated
+    {
+
+        /// <summary>
+        /// Description for FirstName
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("firstName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string FirstName { get; set; }
+
+        /// <summary>
+        /// Description for LastName
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("lastName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string LastName { get; set; }
+
+    }
+
+    /// <summary>
+    /// Represents a product
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        /// <summary>
+        /// Uniquely identifies the product
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        /// <summary>
+        /// Describes the product
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class WeatherForecast
+    {
+
+        [Newtonsoft.Json.JsonProperty("date", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(DateFormatConverter))]
+        public System.DateTimeOffset Date { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("temperatureC", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int TemperatureC { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("summary", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Summary { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("temperatureF", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int TemperatureF { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    internal class DateFormatConverter : Newtonsoft.Json.Converters.IsoDateTimeConverter
+    {
+        public DateFormatConverter()
+        {
+            DateTimeFormat = "yyyy-MM-dd";
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class FileParameter
+    {
+        public FileParameter(System.IO.Stream data)
+            : this (data, null, null)
+        {
+        }
+
+        public FileParameter(System.IO.Stream data, string fileName)
+            : this (data, fileName, null)
+        {
+        }
+
+        public FileParameter(System.IO.Stream data, string fileName, string contentType)
+        {
+            Data = data;
+            FileName = fileName;
+            ContentType = contentType;
+        }
+
+        public System.IO.Stream Data { get; private set; }
+
+        public string FileName { get; private set; }
+
+        public string ContentType { get; private set; }
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f6775c4367939921/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f6775c4367939921/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..25296f73c5
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f6775c4367939921/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,350 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync()
+        {
+            return ProductsAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Product>> ProductsAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "products"
+                    urlBuilder_.Append("products");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Product>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f7cb563c23f74db2/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f7cb563c23f74db2/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..795937b1e2
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f7cb563c23f74db2/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,2347 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <summary>
+        /// CreateFruit
+        /// </summary>
+        /// <remarks>
+        /// Create a fruit
+        /// </remarks>
+        /// <param name="id">The id of the fruit that will be created</param>
+        /// <param name="body">Description for Body</param>
+        /// <returns>Description for response</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Fruit> FruitAsync(string id, Fruit body)
+        {
+            return FruitAsync(id, body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// CreateFruit
+        /// </summary>
+        /// <remarks>
+        /// Create a fruit
+        /// </remarks>
+        /// <param name="id">The id of the fruit that will be created</param>
+        /// <param name="body">Description for Body</param>
+        /// <returns>Description for response</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Fruit> FruitAsync(string id, Fruit body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/fruit/{id}"
+                    urlBuilder_.Append("annotations/fruit/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Fruit>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="firstName">Description for FirstName</param>
+        /// <param name="lastName">Description for LastName</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> SingleFormAsync(string firstName, string lastName)
+        {
+            return SingleFormAsync(firstName, lastName, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="firstName">Description for FirstName</param>
+        /// <param name="lastName">Description for LastName</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> SingleFormAsync(string firstName, string lastName, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (firstName != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("firstName", ConvertToString(firstName, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (lastName != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("lastName", ConvertToString(lastName, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/singleForm"
+                    urlBuilder_.Append("annotations/singleForm");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="street">Description for Street</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> MultipleFormsAsync(string street, string city, string state, string zipCode)
+        {
+            return MultipleFormsAsync(street, city, state, zipCode, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="street">Description for Street</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> MultipleFormsAsync(string street, string city, string state, string zipCode, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (street != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("street", ConvertToString(street, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (city != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("city", ConvertToString(city, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (state != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("state", ConvertToString(state, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (zipCode != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("zipCode", ConvertToString(zipCode, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/multipleForms"
+                    urlBuilder_.Append("annotations/multipleForms");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="file">Description for File</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndStringAsync(FileParameter file, string tags)
+        {
+            return IFromFileAndStringAsync(file, tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="file">Description for File</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndStringAsync(FileParameter file, string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)), "tags");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/IFromFileAndString"
+                    urlBuilder_.Append("annotations/IFromFileAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndEnumAsync(FileParameter file, DateTimeKind? dateTimeKind)
+        {
+            return IFromFileAndEnumAsync(file, dateTimeKind, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndEnumAsync(FileParameter file, DateTimeKind? dateTimeKind, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (dateTimeKind == null)
+                        throw new System.ArgumentNullException("dateTimeKind");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(dateTimeKind, System.Globalization.CultureInfo.InvariantCulture)), "dateTimeKind");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/IFromFileAndEnum"
+                    urlBuilder_.Append("annotations/IFromFileAndEnum");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromObjectAndStringAsync(string tags)
+        {
+            return IFromObjectAndStringAsync(tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromObjectAndStringAsync(string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("tags", ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/IFromObjectAndString"
+                    urlBuilder_.Append("annotations/IFromObjectAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <param name="paramOne">Description</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<AsParametersRecord> AsParametersAsync(System.Guid? paramOne, System.Guid paramTwo, System.DateTimeOffset? paramThree, System.DateTimeOffset paramFour, System.DateTimeOffset? paramFive, System.DateTimeOffset paramSix, System.TimeSpan? paramSeven, System.TimeSpan paramEight, DateTimeKind? paramNine, DateTimeKind paramTen, double? paramEleven, double paramTwelve)
+        {
+            return AsParametersAsync(paramOne, paramTwo, paramThree, paramFour, paramFive, paramSix, paramSeven, paramEight, paramNine, paramTen, paramEleven, paramTwelve, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <param name="paramOne">Description</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<AsParametersRecord> AsParametersAsync(System.Guid? paramOne, System.Guid paramTwo, System.DateTimeOffset? paramThree, System.DateTimeOffset paramFour, System.DateTimeOffset? paramFive, System.DateTimeOffset paramSix, System.TimeSpan? paramSeven, System.TimeSpan paramEight, DateTimeKind? paramNine, DateTimeKind paramTen, double? paramEleven, double paramTwelve, System.Threading.CancellationToken cancellationToken)
+        {
+            if (paramTwo == null)
+                throw new System.ArgumentNullException("paramTwo");
+
+            if (paramFour == null)
+                throw new System.ArgumentNullException("paramFour");
+
+            if (paramSix == null)
+                throw new System.ArgumentNullException("paramSix");
+
+            if (paramEight == null)
+                throw new System.ArgumentNullException("paramEight");
+
+            if (paramTen == null)
+                throw new System.ArgumentNullException("paramTen");
+
+            if (paramTwelve == null)
+                throw new System.ArgumentNullException("paramTwelve");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "annotations/AsParameters"
+                    urlBuilder_.Append("annotations/AsParameters");
+                    urlBuilder_.Append('?');
+                    if (paramOne != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramOne")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramOne, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramTwo")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramTwo, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramThree != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramThree")).Append('=').Append(System.Uri.EscapeDataString(paramThree.Value.ToString("s", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramFour")).Append('=').Append(System.Uri.EscapeDataString(paramFour.ToString("s", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramFive != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramFive")).Append('=').Append(System.Uri.EscapeDataString(paramFive.Value.ToString("yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramSix")).Append('=').Append(System.Uri.EscapeDataString(paramSix.ToString("yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramSeven != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramSeven")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramSeven, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramEight")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramEight, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramNine != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramNine")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramNine, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramTen")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramTen, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (paramEleven != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("paramEleven")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramEleven, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Append(System.Uri.EscapeDataString("paramTwelve")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(paramTwelve, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<AsParametersRecord>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> TypeWithTryParseAsync(string tryParse)
+        {
+            return TypeWithTryParseAsync(tryParse, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> TypeWithTryParseAsync(string tryParse, System.Threading.CancellationToken cancellationToken)
+        {
+            if (tryParse == null)
+                throw new System.ArgumentNullException("tryParse");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "TypeWithTryParse/{tryParse}"
+                    urlBuilder_.Append("TypeWithTryParse/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(tryParse, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<WeatherForecast>> GetWeatherForecastAsync()
+        {
+            return GetWeatherForecastAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<WeatherForecast>> GetWeatherForecastAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/weatherforecast"
+                    urlBuilder_.Append("WithOpenApi/weatherforecast");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<WeatherForecast>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> MultipleForms2Async(string street, string city, string state, string zipCode)
+        {
+            return MultipleForms2Async(street, city, state, zipCode, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> MultipleForms2Async(string street, string city, string state, string zipCode, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (street != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("street", ConvertToString(street, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (city != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("city", ConvertToString(city, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (state != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("state", ConvertToString(state, System.Globalization.CultureInfo.InvariantCulture)));
+                    if (zipCode != null)
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("zipCode", ConvertToString(zipCode, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/multipleForms"
+                    urlBuilder_.Append("WithOpenApi/multipleForms");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAsync(string queryParameter, FileParameter file)
+        {
+            return IFromFileAsync(queryParameter, file, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAsync(string queryParameter, FileParameter file, System.Threading.CancellationToken cancellationToken)
+        {
+            if (queryParameter == null)
+                throw new System.ArgumentNullException("queryParameter");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFile"
+                    urlBuilder_.Append("WithOpenApi/IFromFile");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("queryParameter")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(queryParameter, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileCollectionAsync(System.Collections.Generic.IEnumerable<FileParameter> collection)
+        {
+            return IFromFileCollectionAsync(collection, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileCollectionAsync(System.Collections.Generic.IEnumerable<FileParameter> collection, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (collection == null)
+                        throw new System.ArgumentNullException("collection");
+                    else
+                    {
+                        foreach (var item_ in collection)
+                        {
+                            var content_collection_ = new System.Net.Http.StreamContent(item_.Data);
+                            if (!string.IsNullOrEmpty(item_.ContentType))
+                                content_collection_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(item_.ContentType);
+                            content_.Add(content_collection_, "collection", item_.FileName ?? "collection");
+                        }
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFileCollection"
+                    urlBuilder_.Append("WithOpenApi/IFromFileCollection");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromBodyAsync(OrganizationCustomExchangeRatesDto body)
+        {
+            return IFromBodyAsync(body, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromBodyAsync(OrganizationCustomExchangeRatesDto body, System.Threading.CancellationToken cancellationToken)
+        {
+            if (body == null)
+                throw new System.ArgumentNullException("body");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var json_ = Newtonsoft.Json.JsonConvert.SerializeObject(body, JsonSerializerSettings);
+                    var content_ = new System.Net.Http.StringContent(json_);
+                    content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromBody"
+                    urlBuilder_.Append("WithOpenApi/IFromBody");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndString2Async(FileParameter file, string tags)
+        {
+            return IFromFileAndString2Async(file, tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndString2Async(FileParameter file, string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)), "tags");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFileAndString"
+                    urlBuilder_.Append("WithOpenApi/IFromFileAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromFileAndEnum2Async(FileParameter file, DateTimeKind? dateTimeKind)
+        {
+            return IFromFileAndEnum2Async(file, dateTimeKind, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromFileAndEnum2Async(FileParameter file, DateTimeKind? dateTimeKind, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var boundary_ = System.Guid.NewGuid().ToString();
+                    var content_ = new System.Net.Http.MultipartFormDataContent(boundary_);
+                    content_.Headers.Remove("Content-Type");
+                    content_.Headers.TryAddWithoutValidation("Content-Type", "multipart/form-data; boundary=" + boundary_);
+
+                    if (file == null)
+                        throw new System.ArgumentNullException("file");
+                    else
+                    {
+                        var content_file_ = new System.Net.Http.StreamContent(file.Data);
+                        if (!string.IsNullOrEmpty(file.ContentType))
+                            content_file_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(file.ContentType);
+                        content_.Add(content_file_, "file", file.FileName ?? "file");
+                    }
+
+                    if (dateTimeKind == null)
+                        throw new System.ArgumentNullException("dateTimeKind");
+                    else
+                    {
+                        content_.Add(new System.Net.Http.StringContent(ConvertToString(dateTimeKind, System.Globalization.CultureInfo.InvariantCulture)), "dateTimeKind");
+                    }
+                    request_.Content = content_;
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromFileAndEnum"
+                    urlBuilder_.Append("WithOpenApi/IFromFileAndEnum");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<string> IFromObjectAndString2Async(string tags)
+        {
+            return IFromObjectAndString2Async(tags, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<string> IFromObjectAndString2Async(string tags, System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    var keyValues_ = new System.Collections.Generic.List<System.Collections.Generic.KeyValuePair<string, string>>();
+                    if (tags == null)
+                        throw new System.ArgumentNullException("tags");
+                    else
+                        keyValues_.Add(new System.Collections.Generic.KeyValuePair<string, string>("tags", ConvertToString(tags, System.Globalization.CultureInfo.InvariantCulture)));
+                    request_.Content = new System.Net.Http.FormUrlEncodedContent(keyValues_);
+                    request_.Method = new System.Net.Http.HttpMethod("POST");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "WithOpenApi/IFromObjectAndString"
+                    urlBuilder_.Append("WithOpenApi/IFromObjectAndString");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));
+                            return result_;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <param name="id">The product id</param>
+        /// <returns>A Product Id</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> CarAsync(int id)
+        {
+            return CarAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product
+        /// </summary>
+        /// <param name="id">The product id</param>
+        /// <returns>A Product Id</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> CarAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/Car/{id}"
+                    urlBuilder_.Append("XmlComments/Car/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <param name="id">Uniquely identifies the product</param>
+        /// <param name="description">Describes the product</param>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> Car2Async(int id, string description)
+        {
+            return Car2Async(id, description, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product using asParameters record
+        /// </summary>
+        /// <param name="id">Uniquely identifies the product</param>
+        /// <param name="description">Describes the product</param>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> Car2Async(int id, string description, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/Car"
+                    urlBuilder_.Append("XmlComments/Car");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("Id")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    if (description != null)
+                    {
+                        urlBuilder_.Append(System.Uri.EscapeDataString("Description")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(description, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    }
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> CarWithProducesAsync(int id)
+        {
+            return CarWithProducesAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product With Produces attribute
+        /// </summary>
+        /// <returns>A Product</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> CarWithProducesAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/CarWithProduces"
+                    urlBuilder_.Append("XmlComments/CarWithProduces");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("id")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<Product> CarWithProducesDefaultResponseTypeAsync(int id)
+        {
+            return CarWithProducesDefaultResponseTypeAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Returns a specific product With ProducesDefaultResponseType attribute
+        /// </summary>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<Product> CarWithProducesDefaultResponseTypeAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "XmlComments/CarWithProducesDefaultResponseType"
+                    urlBuilder_.Append("XmlComments/CarWithProducesDefaultResponseType");
+                    urlBuilder_.Append('?');
+                    urlBuilder_.Append(System.Uri.EscapeDataString("id")).Append('=').Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture))).Append('&');
+                    urlBuilder_.Length--;
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<Product>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            throw new ApiException<Product>("A Product", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Address
+    {
+
+        [Newtonsoft.Json.JsonProperty("street", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Street { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("city", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string City { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("state", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string State { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("zipCode", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string ZipCode { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class AddressAnnotated
+    {
+
+        /// <summary>
+        /// Description for Street
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("street", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Street { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("city", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string City { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("state", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string State { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("zipCode", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string ZipCode { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class AsParametersRecord
+    {
+
+        [Newtonsoft.Json.JsonProperty("paramOne", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.Guid? ParamOne { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramTwo", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.Guid ParamTwo { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramThree", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset? ParamThree { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramFour", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.DateTimeOffset ParamFour { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramFive", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(DateFormatConverter))]
+        public System.DateTimeOffset? ParamFive { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramSix", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(DateFormatConverter))]
+        public System.DateTimeOffset ParamSix { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramSeven", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.TimeSpan? ParamSeven { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramEight", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public System.TimeSpan ParamEight { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramNine", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public DateTimeKind ParamNine { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramTen", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public DateTimeKind ParamTen { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramEleven", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public double? ParamEleven { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("paramTwelve", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public double ParamTwelve { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class CurrenciesRate
+    {
+
+        /// <summary>
+        /// Currency From
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("currencyFrom", Required = Newtonsoft.Json.Required.AllowNull)]
+        public string CurrencyFrom { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("currencyTo", Required = Newtonsoft.Json.Required.AllowNull)]
+        public string CurrencyTo { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("rate", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public double Rate { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public enum DateTimeKind
+    {
+
+        _0 = 0,
+
+        _1 = 1,
+
+        _2 = 2,
+
+    }
+
+    /// <summary>
+    /// Description for Schema
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Fruit
+    {
+
+        [Newtonsoft.Json.JsonProperty("name", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Name { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class OrganizationCustomExchangeRatesDto
+    {
+
+        [Newtonsoft.Json.JsonProperty("currenciesRates", Required = Newtonsoft.Json.Required.AllowNull)]
+        public System.Collections.Generic.ICollection<CurrenciesRate> CurrenciesRates { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("isUpdated", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public bool IsUpdated { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Person
+    {
+
+        [Newtonsoft.Json.JsonProperty("firstName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string FirstName { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("lastName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string LastName { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class PersonAnnotated
+    {
+
+        /// <summary>
+        /// Description for FirstName
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("firstName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string FirstName { get; set; }
+
+        /// <summary>
+        /// Description for LastName
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("lastName", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string LastName { get; set; }
+
+    }
+
+    /// <summary>
+    /// Represents a product
+    /// </summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Product
+    {
+
+        /// <summary>
+        /// Uniquely identifies the product
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        /// <summary>
+        /// Describes the product
+        /// </summary>
+        [Newtonsoft.Json.JsonProperty("description", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Description { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class WeatherForecast
+    {
+
+        [Newtonsoft.Json.JsonProperty("date", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(DateFormatConverter))]
+        public System.DateTimeOffset Date { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("temperatureC", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int TemperatureC { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("summary", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Summary { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("temperatureF", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int TemperatureF { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    internal class DateFormatConverter : Newtonsoft.Json.Converters.IsoDateTimeConverter
+    {
+        public DateFormatConverter()
+        {
+            DateTimeFormat = "yyyy-MM-dd";
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class FileParameter
+    {
+        public FileParameter(System.IO.Stream data)
+            : this (data, null, null)
+        {
+        }
+
+        public FileParameter(System.IO.Stream data, string fileName)
+            : this (data, fileName, null)
+        {
+        }
+
+        public FileParameter(System.IO.Stream data, string fileName, string contentType)
+        {
+            Data = data;
+            FileName = fileName;
+            ContentType = contentType;
+        }
+
+        public System.IO.Stream Data { get; private set; }
+
+        public string FileName { get; private set; }
+
+        public string ContentType { get; private set; }
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f93b96252989bd4b/NSwagOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f93b96252989bd4b/NSwagOpenApiClient.verified.cs
new file mode 100644
index 0000000000..86defb12b5
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_f93b96252989bd4b/NSwagOpenApiClient.verified.cs
@@ -0,0 +1,442 @@
+//----------------------
+// <auto-generated>
+//     Generated using the NSwag toolchain v14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+// </auto-generated>
+//----------------------
+
+#pragma warning disable 108 // Disable "CS0108 '{derivedDto}.ToJson()' hides inherited member '{dtoBase}.ToJson()'. Use the new keyword if hiding was intended."
+#pragma warning disable 114 // Disable "CS0114 '{derivedDto}.RaisePropertyChanged(String)' hides inherited member 'dtoBase.RaisePropertyChanged(String)'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword."
+#pragma warning disable 472 // Disable "CS0472 The result of the expression is always 'false' since a value of type 'Int32' is never equal to 'null' of type 'Int32?'
+#pragma warning disable 612 // Disable "CS0612 '...' is obsolete"
+#pragma warning disable 649 // Disable "CS0649 Field is never assigned to, and will always have its default value null"
+#pragma warning disable 1573 // Disable "CS1573 Parameter '...' has no matching param tag in the XML comment for ...
+#pragma warning disable 1591 // Disable "CS1591 Missing XML comment for publicly visible type or member ..."
+#pragma warning disable 8073 // Disable "CS8073 The result of the expression is always 'false' since a value of type 'T' is never equal to 'null' of type 'T?'"
+#pragma warning disable 3016 // Disable "CS3016 Arrays as attribute arguments is not CLS-compliant"
+#pragma warning disable 8600 // Disable "CS8600 Converting null literal or possible null value to non-nullable type"
+#pragma warning disable 8602 // Disable "CS8602 Dereference of a possibly null reference"
+#pragma warning disable 8603 // Disable "CS8603 Possible null reference return"
+#pragma warning disable 8604 // Disable "CS8604 Possible null reference argument for parameter"
+#pragma warning disable 8625 // Disable "CS8625 Cannot convert null literal to non-nullable reference type"
+#pragma warning disable 8765 // Disable "CS8765 Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes)."
+
+namespace Swashbuckle.AspNetCore.IntegrationTests.NSwagTests
+{
+    using System = global::System;
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class NSwagOpenApiClient 
+    {
+        #pragma warning disable 8618
+        private string _baseUrl;
+        #pragma warning restore 8618
+
+        private System.Net.Http.HttpClient _httpClient;
+        private static System.Lazy<Newtonsoft.Json.JsonSerializerSettings> _settings = new System.Lazy<Newtonsoft.Json.JsonSerializerSettings>(CreateSerializerSettings, true);
+        private Newtonsoft.Json.JsonSerializerSettings _instanceSettings;
+
+    #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        public NSwagOpenApiClient(string baseUrl, System.Net.Http.HttpClient httpClient)
+    #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            BaseUrl = baseUrl;
+            _httpClient = httpClient;
+            Initialize();
+        }
+
+        private static Newtonsoft.Json.JsonSerializerSettings CreateSerializerSettings()
+        {
+            var settings = new Newtonsoft.Json.JsonSerializerSettings();
+            UpdateJsonSerializerSettings(settings);
+            return settings;
+        }
+
+        public string BaseUrl
+        {
+            get { return _baseUrl; }
+            set
+            {
+                _baseUrl = value;
+                if (!string.IsNullOrEmpty(_baseUrl) && !_baseUrl.EndsWith("/"))
+                    _baseUrl += '/';
+            }
+        }
+
+        protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get { return _instanceSettings ?? _settings.Value; } }
+
+        static partial void UpdateJsonSerializerSettings(Newtonsoft.Json.JsonSerializerSettings settings);
+
+        partial void Initialize();
+
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, string url);
+        partial void PrepareRequest(System.Net.Http.HttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder);
+        partial void ProcessResponse(System.Net.Http.HttpClient client, System.Net.Http.HttpResponseMessage response);
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Todo>> TodosAllAsync()
+        {
+            return TodosAllAsync(System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<Todo>> TodosAllAsync(System.Threading.CancellationToken cancellationToken)
+        {
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "todos"
+                    urlBuilder_.Append("todos");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<Todo>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task TodosAsync(int id)
+        {
+            return TodosAsync(id, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task TodosAsync(int id, System.Threading.CancellationToken cancellationToken)
+        {
+            if (id == null)
+                throw new System.ArgumentNullException("id");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "todos/{id}"
+                    urlBuilder_.Append("todos/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(id, System.Globalization.CultureInfo.InvariantCulture)));
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            return;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await ReadAsStringAsync(response_.Content, cancellationToken).ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
+        protected struct ObjectResponseResult<T>
+        {
+            public ObjectResponseResult(T responseObject, string responseText)
+            {
+                this.Object = responseObject;
+                this.Text = responseText;
+            }
+
+            public T Object { get; }
+
+            public string Text { get; }
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<string> ReadAsStringAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStringAsync(cancellationToken);
+    #else
+            return content.ReadAsStringAsync();
+    #endif
+        }
+
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        private static System.Threading.Tasks.Task<System.IO.Stream> ReadAsStreamAsync(System.Net.Http.HttpContent content, System.Threading.CancellationToken cancellationToken)
+        {
+    #if NET5_0_OR_GREATER
+            return content.ReadAsStreamAsync(cancellationToken);
+    #else
+            return content.ReadAsStreamAsync();
+    #endif
+        }
+
+        public bool ReadResponseAsString { get; set; }
+
+        protected virtual async System.Threading.Tasks.Task<ObjectResponseResult<T>> ReadObjectResponseAsync<T>(System.Net.Http.HttpResponseMessage response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Threading.CancellationToken cancellationToken)
+        {
+            if (response == null || response.Content == null)
+            {
+                return new ObjectResponseResult<T>(default(T), string.Empty);
+            }
+
+            if (ReadResponseAsString)
+            {
+                var responseText = await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    var typedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(responseText, JsonSerializerSettings);
+                    return new ObjectResponseResult<T>(typedBody, responseText);
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body string as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, responseText, headers, exception);
+                }
+            }
+            else
+            {
+                try
+                {
+                    using (var responseStream = await ReadAsStreamAsync(response.Content, cancellationToken).ConfigureAwait(false))
+                    using (var streamReader = new System.IO.StreamReader(responseStream))
+                    using (var jsonTextReader = new Newtonsoft.Json.JsonTextReader(streamReader))
+                    {
+                        var serializer = Newtonsoft.Json.JsonSerializer.Create(JsonSerializerSettings);
+                        var typedBody = serializer.Deserialize<T>(jsonTextReader);
+                        return new ObjectResponseResult<T>(typedBody, string.Empty);
+                    }
+                }
+                catch (Newtonsoft.Json.JsonException exception)
+                {
+                    var message = "Could not deserialize the response body stream as " + typeof(T).FullName + ".";
+                    throw new ApiException(message, (int)response.StatusCode, string.Empty, headers, exception);
+                }
+            }
+        }
+
+        private string ConvertToString(object value, System.Globalization.CultureInfo cultureInfo)
+        {
+            if (value == null)
+            {
+                return "";
+            }
+
+            if (value is System.Enum)
+            {
+                var name = System.Enum.GetName(value.GetType(), value);
+                if (name != null)
+                {
+                    var field_ = System.Reflection.IntrospectionExtensions.GetTypeInfo(value.GetType()).GetDeclaredField(name);
+                    if (field_ != null)
+                    {
+                        var attribute = System.Reflection.CustomAttributeExtensions.GetCustomAttribute(field_, typeof(System.Runtime.Serialization.EnumMemberAttribute)) 
+                            as System.Runtime.Serialization.EnumMemberAttribute;
+                        if (attribute != null)
+                        {
+                            return attribute.Value != null ? attribute.Value : name;
+                        }
+                    }
+
+                    var converted = System.Convert.ToString(System.Convert.ChangeType(value, System.Enum.GetUnderlyingType(value.GetType()), cultureInfo));
+                    return converted == null ? string.Empty : converted;
+                }
+            }
+            else if (value is bool) 
+            {
+                return System.Convert.ToString((bool)value, cultureInfo).ToLowerInvariant();
+            }
+            else if (value is byte[])
+            {
+                return System.Convert.ToBase64String((byte[]) value);
+            }
+            else if (value is string[])
+            {
+                return string.Join(",", (string[])value);
+            }
+            else if (value.GetType().IsArray)
+            {
+                var valueArray = (System.Array)value;
+                var valueTextArray = new string[valueArray.Length];
+                for (var i = 0; i < valueArray.Length; i++)
+                {
+                    valueTextArray[i] = ConvertToString(valueArray.GetValue(i), cultureInfo);
+                }
+                return string.Join(",", valueTextArray);
+            }
+
+            var result = System.Convert.ToString(value, cultureInfo);
+            return result == null ? "" : result;
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class Todo
+    {
+
+        [Newtonsoft.Json.JsonProperty("id", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public int Id { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("title", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public string Title { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("dueBy", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [Newtonsoft.Json.JsonConverter(typeof(DateFormatConverter))]
+        public System.DateTimeOffset? DueBy { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("isComplete", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public bool IsComplete { get; set; }
+
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    internal class DateFormatConverter : Newtonsoft.Json.Converters.IsoDateTimeConverter
+    {
+        public DateFormatConverter()
+        {
+            DateTimeFormat = "yyyy-MM-dd";
+        }
+    }
+
+
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException : System.Exception
+    {
+        public int StatusCode { get; private set; }
+
+        public string Response { get; private set; }
+
+        public System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> Headers { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, System.Exception innerException)
+            : base(message + "\n\nStatus: " + statusCode + "\nResponse: \n" + ((response == null) ? "(null)" : response.Substring(0, response.Length >= 512 ? 512 : response.Length)), innerException)
+        {
+            StatusCode = statusCode;
+            Response = response;
+            Headers = headers;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("HTTP Response: \n\n{0}\n\n{1}", Response, base.ToString());
+        }
+    }
+
+    [System.CodeDom.Compiler.GeneratedCode("NSwag", "14.6.3.0 (NJsonSchema v11.5.2.0 (Newtonsoft.Json v13.0.0.0))")]
+    public partial class ApiException<TResult> : ApiException
+    {
+        public TResult Result { get; private set; }
+
+        public ApiException(string message, int statusCode, string response, System.Collections.Generic.IReadOnlyDictionary<string, System.Collections.Generic.IEnumerable<string>> headers, TResult result, System.Exception innerException)
+            : base(message, statusCode, response, headers, innerException)
+        {
+            Result = result;
+        }
+    }
+
+}
+
+#pragma warning restore  108
+#pragma warning restore  114
+#pragma warning restore  472
+#pragma warning restore  612
+#pragma warning restore  649
+#pragma warning restore 1573
+#pragma warning restore 1591
+#pragma warning restore 8073
+#pragma warning restore 3016
+#pragma warning restore 8600
+#pragma warning restore 8602
+#pragma warning restore 8603
+#pragma warning restore 8604
+#pragma warning restore 8625
+#pragma warning restore 8765
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/KiotaOpenApiClient.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/KiotaOpenApiClient.verified.cs
new file mode 100644
index 0000000000..829aa7a776
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/KiotaOpenApiClient.verified.cs
@@ -0,0 +1,43 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Form;
+using Microsoft.Kiota.Serialization.Json;
+using Microsoft.Kiota.Serialization.Multipart;
+using Microsoft.Kiota.Serialization.Text;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests
+{
+    /// <summary>
+    /// The main entry point of the SDK, exposes the configuration and the fluent API.
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class KiotaOpenApiClient : BaseRequestBuilder
+    {
+        /// <summary>The weatherforecast property</summary>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast.WeatherforecastRequestBuilder Weatherforecast
+        {
+            get => new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast.WeatherforecastRequestBuilder(PathParameters, RequestAdapter);
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.KiotaOpenApiClient"/> and sets the default values.
+        /// </summary>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public KiotaOpenApiClient(IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}", new Dictionary<string, object>())
+        {
+            ApiClientBuilder.RegisterDefaultSerializer<JsonSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<TextSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<FormSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultSerializer<MultipartSerializationWriterFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<JsonParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<TextParseNodeFactory>();
+            ApiClientBuilder.RegisterDefaultDeserializer<FormParseNodeFactory>();
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Models/Child.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Models/Child.verified.cs
new file mode 100644
index 0000000000..bb075a8ff9
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Models/Child.verified.cs
@@ -0,0 +1,55 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Child : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The name property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public string? Name { get; set; }
+#nullable restore
+#else
+        public string Name { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "name", n => { Name = n.GetStringValue(); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteStringValue("name", Name);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Models/Parent.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Models/Parent.verified.cs
new file mode 100644
index 0000000000..4405ca15fe
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Models/Parent.verified.cs
@@ -0,0 +1,59 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using System.Collections.Generic;
+using System.IO;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    #pragma warning disable CS1591
+    public partial class Parent : IParsable
+    #pragma warning restore CS1591
+    {
+        /// <summary>The category property</summary>
+        public int? Category { get; set; }
+        /// <summary>The child property</summary>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child? Child { get; set; }
+#nullable restore
+#else
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child Child { get; set; }
+#endif
+        /// <summary>
+        /// Creates a new instance of the appropriate class based on discriminator value
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Parent"/></returns>
+        /// <param name="parseNode">The parse node to use to read the discriminator value and create the object</param>
+        public static global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Parent CreateFromDiscriminatorValue(IParseNode parseNode)
+        {
+            if(ReferenceEquals(parseNode, null)) throw new ArgumentNullException(nameof(parseNode));
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Parent();
+        }
+        /// <summary>
+        /// The deserialization information for the current model
+        /// </summary>
+        /// <returns>A IDictionary&lt;string, Action&lt;IParseNode&gt;&gt;</returns>
+        public virtual IDictionary<string, Action<IParseNode>> GetFieldDeserializers()
+        {
+            return new Dictionary<string, Action<IParseNode>>
+            {
+                { "category", n => { Category = n.GetIntValue(); } },
+                { "child", n => { Child = n.GetObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child>(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child.CreateFromDiscriminatorValue); } },
+            };
+        }
+        /// <summary>
+        /// Serializes information the current object
+        /// </summary>
+        /// <param name="writer">Serialization writer to use to serialize this model</param>
+        public virtual void Serialize(ISerializationWriter writer)
+        {
+            if(ReferenceEquals(writer, null)) throw new ArgumentNullException(nameof(writer));
+            writer.WriteIntValue("category", Category);
+            writer.WriteObjectValue<global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Child>("child", Child);
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Weatherforecast/WeatherforecastRequestBuilder.verified.cs b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Weatherforecast/WeatherforecastRequestBuilder.verified.cs
new file mode 100644
index 0000000000..49d9856bcf
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/GeneratesValidClient_fed5e45cef80b2b2/Weatherforecast/WeatherforecastRequestBuilder.verified.cs
@@ -0,0 +1,90 @@
+// <auto-generated/>
+#pragma warning disable CS0618
+using Microsoft.Kiota.Abstractions.Extensions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Abstractions;
+using Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using System.Threading;
+using System;
+namespace Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast
+{
+    /// <summary>
+    /// Builds and executes requests for operations under \weatherforecast
+    /// </summary>
+    [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+    public partial class WeatherforecastRequestBuilder : BaseRequestBuilder
+    {
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast.WeatherforecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="pathParameters">Path parameters for the request</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherforecastRequestBuilder(Dictionary<string, object> pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/weatherforecast", pathParameters)
+        {
+        }
+        /// <summary>
+        /// Instantiates a new <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast.WeatherforecastRequestBuilder"/> and sets the default values.
+        /// </summary>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        /// <param name="requestAdapter">The request adapter to use to execute the requests.</param>
+        public WeatherforecastRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/weatherforecast", rawUrl)
+        {
+        }
+        /// <returns>A <see cref="Stream"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="cancellationToken">Cancellation token to use when cancelling requests</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public async Task<Stream?> GetAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Parent body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#nullable restore
+#else
+        public async Task<Stream> GetAsync(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Parent body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default, CancellationToken cancellationToken = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = ToGetRequestInformation(body, requestConfiguration);
+            return await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, default, cancellationToken).ConfigureAwait(false);
+        }
+        /// <returns>A <see cref="RequestInformation"/></returns>
+        /// <param name="body">The request body</param>
+        /// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
+#nullable enable
+        public RequestInformation ToGetRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Parent body, Action<RequestConfiguration<DefaultQueryParameters>>? requestConfiguration = default)
+        {
+#nullable restore
+#else
+        public RequestInformation ToGetRequestInformation(global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Models.Parent body, Action<RequestConfiguration<DefaultQueryParameters>> requestConfiguration = default)
+        {
+#endif
+            if(ReferenceEquals(body, null)) throw new ArgumentNullException(nameof(body));
+            var requestInfo = new RequestInformation(Method.GET, UrlTemplate, PathParameters);
+            requestInfo.Configure(requestConfiguration);
+            requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
+            return requestInfo;
+        }
+        /// <summary>
+        /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        /// </summary>
+        /// <returns>A <see cref="global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast.WeatherforecastRequestBuilder"/></returns>
+        /// <param name="rawUrl">The raw URL to use for the request builder.</param>
+        public global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast.WeatherforecastRequestBuilder WithUrl(string rawUrl)
+        {
+            return new global::Swashbuckle.AspNetCore.IntegrationTests.KiotaTests.Weatherforecast.WeatherforecastRequestBuilder(rawUrl, RequestAdapter);
+        }
+        /// <summary>
+        /// Configuration for the request such as headers, query parameters, and middleware options.
+        /// </summary>
+        [Obsolete("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.")]
+        [global::System.CodeDom.Compiler.GeneratedCode("Kiota", "1.0.0")]
+        public partial class WeatherforecastRequestBuilderGetRequestConfiguration : RequestConfiguration<DefaultQueryParameters>
+        {
+        }
+    }
+}
+#pragma warning restore CS0618
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt
index 2b12527895..f5c7e14f4c 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt
@@ -48,12 +48,9 @@
         "type": "object",
         "properties": {
           "child": {
-            "oneOf": [
+            "allOf": [
               {
                 "$ref": "#/components/schemas/Child"
-              },
-              {
-                "type": "null"
               }
             ]
           },
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet8_0.verified.txt b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet8_0.verified.txt
index 2b12527895..f5c7e14f4c 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet8_0.verified.txt
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet8_0.verified.txt
@@ -48,12 +48,9 @@
         "type": "object",
         "properties": {
           "child": {
-            "oneOf": [
+            "allOf": [
               {
                 "$ref": "#/components/schemas/Child"
-              },
-              {
-                "type": "null"
               }
             ]
           },
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet9_0.verified.txt b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet9_0.verified.txt
index 2b12527895..f5c7e14f4c 100644
--- a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet9_0.verified.txt
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=MinimalAppWithNullableEnums.Program_swaggerRequestUri=v1.DotNet9_0.verified.txt
@@ -48,12 +48,9 @@
         "type": "object",
         "properties": {
           "child": {
-            "oneOf": [
+            "allOf": [
               {
                 "$ref": "#/components/schemas/Child"
-              },
-              {
-                "type": "null"
               }
             ]
           },
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt
new file mode 100644
index 0000000000..cf2b5c482a
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet10_0.verified.txt
@@ -0,0 +1,474 @@
+{
+  "openapi": "3.0.4",
+  "info": {
+    "title": "Todo API",
+    "version": "v1"
+  },
+  "paths": {
+    "/api/items": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Get all Todo items",
+        "description": "Gets all of the current user's todo items.",
+        "operationId": "ListTodos",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Create a new Todo item",
+        "description": "Creates a new todo item for the current user and returns its ID.",
+        "operationId": "CreateTodo",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/CreateTodoItemModel"
+                  }
+                ],
+                "description": "Represents the model for creating a new Todo item."
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CreatedTodoItemModel"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Get a specific Todo item",
+        "description": "Gets the todo item with the specified ID.",
+        "operationId": "GetTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoItemModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Delete a Todo item",
+        "description": "Deletes the todo item with the specified ID.",
+        "operationId": "DeleteTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}/complete": {
+      "post": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Mark a Todo item as completed",
+        "description": "Marks the todo item with the specified ID as complete.",
+        "operationId": "CompleteTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}/priority": {
+      "patch": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Updates the priority of a Todo item",
+        "description": "Updates the priority of the todo item with the specified ID to the specified priority.",
+        "operationId": "UpdateTodoPriority",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/UpdateTodoItemPriorityModel"
+                  }
+                ],
+                "description": "Represents the model for updating the priority of a Todo item."
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/find": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "operationId": "FindTodo",
+        "parameters": [
+          {
+            "name": "Text",
+            "in": "query",
+            "description": "Gets or sets the text of the filter.",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "IsCompleted",
+            "in": "query",
+            "description": "Gets or sets a value indicating whether to search completed Todo items.",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/getAfter": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "operationId": "GetAfterDate",
+        "parameters": [
+          {
+            "name": "value",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "CreateTodoItemModel": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string",
+            "description": "Gets or sets the text of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for creating a new Todo item."
+      },
+      "CreatedTodoItemModel": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Gets or sets the ID of the created Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for a created Todo item."
+      },
+      "ProblemDetails": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "nullable": true
+          },
+          "title": {
+            "type": "string",
+            "nullable": true
+          },
+          "status": {
+            "type": "integer",
+            "format": "int32",
+            "nullable": true
+          },
+          "detail": {
+            "type": "string",
+            "nullable": true
+          },
+          "instance": {
+            "type": "string",
+            "nullable": true
+          }
+        },
+        "additionalProperties": { }
+      },
+      "TodoItemModel": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Gets or sets the ID of the Todo item."
+          },
+          "text": {
+            "type": "string",
+            "description": "Gets or sets the text of the Todo item."
+          },
+          "createdAt": {
+            "type": "string",
+            "description": "Gets or sets the date and time the item was created.",
+            "format": "date-time"
+          },
+          "completedAt": {
+            "type": "string",
+            "description": "Gets or sets the date and time the item was completed.",
+            "format": "date-time",
+            "nullable": true
+          },
+          "lastUpdated": {
+            "type": "string",
+            "description": "Gets or sets the date and time the Todo item was last updated.",
+            "format": "date-time"
+          },
+          "priority": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/TodoPriority"
+              }
+            ],
+            "description": "Gets or sets the optional priority of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents a Todo item."
+      },
+      "TodoListViewModel": {
+        "type": "object",
+        "properties": {
+          "items": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/TodoItemModel"
+            },
+            "description": "Gets or sets the Todo item(s)."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents a collection of Todo items."
+      },
+      "TodoPriority": {
+        "enum": [
+          "Normal",
+          "Low",
+          "High"
+        ],
+        "type": "string",
+        "description": "The priority levels for a Todo item."
+      },
+      "UpdateTodoItemPriorityModel": {
+        "type": "object",
+        "properties": {
+          "priority": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/TodoPriority"
+              }
+            ],
+            "description": "Gets or sets the new priority of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for updating the priority of a Todo item."
+      }
+    }
+  },
+  "tags": [
+    {
+      "name": "TodoApp"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet8_0.verified.txt b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet8_0.verified.txt
new file mode 100644
index 0000000000..fc9cebee4f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet8_0.verified.txt
@@ -0,0 +1,472 @@
+{
+  "openapi": "3.0.4",
+  "info": {
+    "title": "Todo API",
+    "version": "v1"
+  },
+  "paths": {
+    "/api/items": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Get all Todo items",
+        "description": "Gets all of the current user's todo items.",
+        "operationId": "ListTodos",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Create a new Todo item",
+        "description": "Creates a new todo item for the current user and returns its ID.",
+        "operationId": "CreateTodo",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/CreateTodoItemModel"
+                  }
+                ],
+                "description": "Represents the model for creating a new Todo item."
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CreatedTodoItemModel"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Get a specific Todo item",
+        "description": "Gets the todo item with the specified ID.",
+        "operationId": "GetTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoItemModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Delete a Todo item",
+        "description": "Deletes the todo item with the specified ID.",
+        "operationId": "DeleteTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}/complete": {
+      "post": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Mark a Todo item as completed",
+        "description": "Marks the todo item with the specified ID as complete.",
+        "operationId": "CompleteTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}/priority": {
+      "patch": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Updates the priority of a Todo item",
+        "description": "Updates the priority of the todo item with the specified ID to the specified priority.",
+        "operationId": "UpdateTodoPriority",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/UpdateTodoItemPriorityModel"
+                  }
+                ],
+                "description": "Represents the model for updating the priority of a Todo item."
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/find": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "operationId": "FindTodo",
+        "parameters": [
+          {
+            "name": "Text",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "IsCompleted",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/getAfter": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "operationId": "GetAfterDate",
+        "parameters": [
+          {
+            "name": "value",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "CreateTodoItemModel": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string",
+            "description": "Gets or sets the text of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for creating a new Todo item."
+      },
+      "CreatedTodoItemModel": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Gets or sets the ID of the created Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for a created Todo item."
+      },
+      "ProblemDetails": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "nullable": true
+          },
+          "title": {
+            "type": "string",
+            "nullable": true
+          },
+          "status": {
+            "type": "integer",
+            "format": "int32",
+            "nullable": true
+          },
+          "detail": {
+            "type": "string",
+            "nullable": true
+          },
+          "instance": {
+            "type": "string",
+            "nullable": true
+          }
+        },
+        "additionalProperties": { }
+      },
+      "TodoItemModel": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Gets or sets the ID of the Todo item."
+          },
+          "text": {
+            "type": "string",
+            "description": "Gets or sets the text of the Todo item."
+          },
+          "createdAt": {
+            "type": "string",
+            "description": "Gets or sets the date and time the item was created.",
+            "format": "date-time"
+          },
+          "completedAt": {
+            "type": "string",
+            "description": "Gets or sets the date and time the item was completed.",
+            "format": "date-time",
+            "nullable": true
+          },
+          "lastUpdated": {
+            "type": "string",
+            "description": "Gets or sets the date and time the Todo item was last updated.",
+            "format": "date-time"
+          },
+          "priority": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/TodoPriority"
+              }
+            ],
+            "description": "Gets or sets the optional priority of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents a Todo item."
+      },
+      "TodoListViewModel": {
+        "type": "object",
+        "properties": {
+          "items": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/TodoItemModel"
+            },
+            "description": "Gets or sets the Todo item(s)."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents a collection of Todo items."
+      },
+      "TodoPriority": {
+        "enum": [
+          "Normal",
+          "Low",
+          "High"
+        ],
+        "type": "string",
+        "description": "The priority levels for a Todo item."
+      },
+      "UpdateTodoItemPriorityModel": {
+        "type": "object",
+        "properties": {
+          "priority": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/TodoPriority"
+              }
+            ],
+            "description": "Gets or sets the new priority of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for updating the priority of a Todo item."
+      }
+    }
+  },
+  "tags": [
+    {
+      "name": "TodoApp"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet9_0.verified.txt b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet9_0.verified.txt
new file mode 100644
index 0000000000..fc9cebee4f
--- /dev/null
+++ b/test/Swashbuckle.AspNetCore.IntegrationTests/snapshots/VerifyTests.Swagger_IsValidJson_No_Startup_entryPointType=TodoApp.Program_swaggerRequestUri=v1.DotNet9_0.verified.txt
@@ -0,0 +1,472 @@
+{
+  "openapi": "3.0.4",
+  "info": {
+    "title": "Todo API",
+    "version": "v1"
+  },
+  "paths": {
+    "/api/items": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Get all Todo items",
+        "description": "Gets all of the current user's todo items.",
+        "operationId": "ListTodos",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Create a new Todo item",
+        "description": "Creates a new todo item for the current user and returns its ID.",
+        "operationId": "CreateTodo",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/CreateTodoItemModel"
+                  }
+                ],
+                "description": "Represents the model for creating a new Todo item."
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CreatedTodoItemModel"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Get a specific Todo item",
+        "description": "Gets the todo item with the specified ID.",
+        "operationId": "GetTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoItemModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Delete a Todo item",
+        "description": "Deletes the todo item with the specified ID.",
+        "operationId": "DeleteTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}/complete": {
+      "post": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Mark a Todo item as completed",
+        "description": "Marks the todo item with the specified ID as complete.",
+        "operationId": "CompleteTodo",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/{id}/priority": {
+      "patch": {
+        "tags": [
+          "TodoApp"
+        ],
+        "summary": "Updates the priority of a Todo item",
+        "description": "Updates the priority of the todo item with the specified ID to the specified priority.",
+        "operationId": "UpdateTodoPriority",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "The Todo item's ID.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "description": "The Todo item's ID.",
+              "format": "uuid"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/UpdateTodoItemPriorityModel"
+                  }
+                ],
+                "description": "Represents the model for updating the priority of a Todo item."
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/problem+json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/find": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "operationId": "FindTodo",
+        "parameters": [
+          {
+            "name": "Text",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "IsCompleted",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/items/getAfter": {
+      "get": {
+        "tags": [
+          "TodoApp"
+        ],
+        "operationId": "GetAfterDate",
+        "parameters": [
+          {
+            "name": "value",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TodoListViewModel"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "CreateTodoItemModel": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string",
+            "description": "Gets or sets the text of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for creating a new Todo item."
+      },
+      "CreatedTodoItemModel": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Gets or sets the ID of the created Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for a created Todo item."
+      },
+      "ProblemDetails": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "nullable": true
+          },
+          "title": {
+            "type": "string",
+            "nullable": true
+          },
+          "status": {
+            "type": "integer",
+            "format": "int32",
+            "nullable": true
+          },
+          "detail": {
+            "type": "string",
+            "nullable": true
+          },
+          "instance": {
+            "type": "string",
+            "nullable": true
+          }
+        },
+        "additionalProperties": { }
+      },
+      "TodoItemModel": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Gets or sets the ID of the Todo item."
+          },
+          "text": {
+            "type": "string",
+            "description": "Gets or sets the text of the Todo item."
+          },
+          "createdAt": {
+            "type": "string",
+            "description": "Gets or sets the date and time the item was created.",
+            "format": "date-time"
+          },
+          "completedAt": {
+            "type": "string",
+            "description": "Gets or sets the date and time the item was completed.",
+            "format": "date-time",
+            "nullable": true
+          },
+          "lastUpdated": {
+            "type": "string",
+            "description": "Gets or sets the date and time the Todo item was last updated.",
+            "format": "date-time"
+          },
+          "priority": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/TodoPriority"
+              }
+            ],
+            "description": "Gets or sets the optional priority of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents a Todo item."
+      },
+      "TodoListViewModel": {
+        "type": "object",
+        "properties": {
+          "items": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/TodoItemModel"
+            },
+            "description": "Gets or sets the Todo item(s)."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents a collection of Todo items."
+      },
+      "TodoPriority": {
+        "enum": [
+          "Normal",
+          "Low",
+          "High"
+        ],
+        "type": "string",
+        "description": "The priority levels for a Todo item."
+      },
+      "UpdateTodoItemPriorityModel": {
+        "type": "object",
+        "properties": {
+          "priority": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/TodoPriority"
+              }
+            ],
+            "description": "Gets or sets the new priority of the Todo item."
+          }
+        },
+        "additionalProperties": false,
+        "description": "Represents the model for updating the priority of a Todo item."
+      }
+    }
+  },
+  "tags": [
+    {
+      "name": "TodoApp"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/WebSites/TodoApp/ApiEndpoints.cs b/test/WebSites/TodoApp/ApiEndpoints.cs
new file mode 100644
index 0000000000..6efa9b0b92
--- /dev/null
+++ b/test/WebSites/TodoApp/ApiEndpoints.cs
@@ -0,0 +1,187 @@
+using System.ComponentModel;
+using Microsoft.EntityFrameworkCore;
+using TodoApp.Data;
+using TodoApp.Models;
+
+namespace TodoApp;
+
+public static class ApiEndpoints
+{
+    public static IServiceCollection AddTodoApi(this IServiceCollection services)
+    {
+        services.AddSingleton(TimeProvider.System);
+        services.AddScoped<TodoRepository>();
+        services.AddScoped<TodoService>();
+
+        services.AddDbContext<TodoContext>((options) => options.UseInMemoryDatabase("Todos"));
+
+        services.ConfigureHttpJsonOptions((options) =>
+        {
+            options.SerializerOptions.DefaultIgnoreCondition = TodoJsonSerializerContext.Default.Options.DefaultIgnoreCondition;
+            options.SerializerOptions.NumberHandling = TodoJsonSerializerContext.Default.Options.NumberHandling;
+            options.SerializerOptions.PropertyNamingPolicy = TodoJsonSerializerContext.Default.Options.PropertyNamingPolicy;
+            options.SerializerOptions.WriteIndented = TodoJsonSerializerContext.Default.Options.WriteIndented;
+            options.SerializerOptions.TypeInfoResolverChain.Add(TodoJsonSerializerContext.Default);
+
+            options.SerializerOptions.Converters.Clear();
+
+            foreach (var converter in TodoJsonSerializerContext.Default.Options.Converters)
+            {
+                options.SerializerOptions.Converters.Add(converter);
+            }
+        });
+
+        return services;
+    }
+
+    public static IEndpointRouteBuilder MapTodoApiRoutes(this IEndpointRouteBuilder builder)
+    {
+        var group = builder.MapGroup("/api/items")
+                           .WithTags("TodoApp");
+        {
+            group.MapGet("/", async (TodoService service, CancellationToken cancellationToken) => await service.GetListAsync(cancellationToken))
+                 .WithName("ListTodos")
+                 .WithSummary("Get all Todo items")
+                 .WithDescription("Gets all of the current user's todo items.")
+                 .Produces<TodoListViewModel>(StatusCodes.Status200OK);
+
+            group.MapGet(
+                "/{id}",
+                async (
+                    [Description("The Todo item's ID.")] Guid id,
+                    TodoService service,
+                    CancellationToken cancellationToken) =>
+                {
+                    var model = await service.GetAsync(id, cancellationToken);
+                    return model switch
+                    {
+                        null => Results.Problem("Item not found.", statusCode: StatusCodes.Status404NotFound),
+                        _ => Results.Ok(model),
+                    };
+                })
+                .WithName("GetTodo")
+                .WithSummary("Get a specific Todo item")
+                .WithDescription("Gets the todo item with the specified ID.")
+                .Produces<TodoItemModel>(StatusCodes.Status200OK)
+                .ProducesProblem(StatusCodes.Status404NotFound);
+
+            group.MapPost(
+                "/",
+                async (
+                    [Description("The Todo item to create.")] CreateTodoItemModel model,
+                    TodoService service,
+                    CancellationToken cancellationToken) =>
+                {
+                    if (string.IsNullOrWhiteSpace(model.Text))
+                    {
+                        return Results.Problem("No item text specified.", statusCode: StatusCodes.Status400BadRequest);
+                    }
+
+                    var id = await service.AddItemAsync(model.Text, cancellationToken);
+
+                    return Results.Created($"/api/items/{id}", new CreatedTodoItemModel() { Id = id });
+                })
+                .WithName("CreateTodo")
+                .WithSummary("Create a new Todo item")
+                .WithDescription("Creates a new todo item for the current user and returns its ID.")
+                .Produces<CreatedTodoItemModel>(StatusCodes.Status201Created)
+                .ProducesProblem(StatusCodes.Status400BadRequest);
+
+            group.MapPost(
+                "/{id}/complete",
+                async (
+                    [Description("The Todo item's ID.")] Guid id,
+                    TodoService service,
+                    CancellationToken cancellationToken) =>
+                {
+                    var wasCompleted = await service.CompleteItemAsync(id, cancellationToken);
+
+                    return wasCompleted switch
+                    {
+                        true => Results.NoContent(),
+                        false => Results.Problem("Item already completed.", statusCode: StatusCodes.Status400BadRequest),
+                        _ => Results.Problem("Item not found.", statusCode: StatusCodes.Status404NotFound),
+                    };
+                })
+                .WithName("CompleteTodo")
+                .WithSummary("Mark a Todo item as completed")
+                .WithDescription("Marks the todo item with the specified ID as complete.")
+                .Produces(StatusCodes.Status204NoContent)
+                .ProducesProblem(StatusCodes.Status400BadRequest)
+                .ProducesProblem(StatusCodes.Status404NotFound);
+
+            group.MapDelete(
+                "/{id}",
+                async (
+                    [Description("The Todo item's ID.")] Guid id,
+                    TodoService service,
+                    CancellationToken cancellationToken) =>
+                {
+                    var wasDeleted = await service.DeleteItemAsync(id, cancellationToken);
+                    return wasDeleted switch
+                    {
+                        true => Results.NoContent(),
+                        false => Results.Problem("Item not found.", statusCode: StatusCodes.Status404NotFound),
+                    };
+                })
+                .WithName("DeleteTodo")
+                .WithSummary("Delete a Todo item")
+                .WithDescription("Deletes the todo item with the specified ID.")
+                .Produces(StatusCodes.Status204NoContent)
+                .ProducesProblem(StatusCodes.Status404NotFound);
+
+            group.MapPatch(
+                "/{id}/priority",
+                async (
+                    [Description("The Todo item's ID.")] Guid id,
+                    [Description("The Todo item's new priority.")] UpdateTodoItemPriorityModel priority,
+                    TodoService service,
+                    CancellationToken cancellationToken) =>
+                {
+                    if (priority.Priority < TodoPriority.Low || priority.Priority > TodoPriority.High)
+                    {
+                        return Results.Problem("Invalid priority.", statusCode: StatusCodes.Status400BadRequest);
+                    }
+
+                    var wasUpdated = await service.SetPriorityAsync(id, priority.Priority, cancellationToken);
+
+                    return wasUpdated switch
+                    {
+                        true => Results.NoContent(),
+                        false => Results.Problem("Item not found.", statusCode: StatusCodes.Status404NotFound),
+                    };
+                })
+                .WithName("UpdateTodoPriority")
+                .WithSummary("Updates the priority of a Todo item")
+                .WithDescription("Updates the priority of the todo item with the specified ID to the specified priority.")
+                .Produces(StatusCodes.Status204NoContent)
+                .ProducesProblem(StatusCodes.Status400BadRequest)
+                .ProducesProblem(StatusCodes.Status404NotFound);
+
+            group.MapGet("/find", FindTodoItem)
+                 .WithName("FindTodo")
+                 .Produces<TodoListViewModel>();
+
+            group.MapGet("/getAfter", GetAfterDate)
+                 .WithName("GetAfterDate")
+                 .Produces<TodoListViewModel>();
+        }
+
+        builder.MapGet("/", () => Results.Redirect("/swagger"))
+               .ExcludeFromDescription();
+
+        return builder;
+    }
+
+    private static async Task<TodoListViewModel> FindTodoItem(
+        [AsParameters] TodoItemFilterModel filter,
+        TodoService service,
+        CancellationToken cancellationToken) =>
+        await service.FindAsync(filter, cancellationToken);
+
+    private static async Task<TodoListViewModel> GetAfterDate(
+        DateTime value,
+        TodoService service,
+        CancellationToken cancellationToken) =>
+        await service.GetAfterDateAsync(value, cancellationToken);
+}
diff --git a/test/WebSites/TodoApp/Data/TodoContext.cs b/test/WebSites/TodoApp/Data/TodoContext.cs
new file mode 100644
index 0000000000..37d484abf3
--- /dev/null
+++ b/test/WebSites/TodoApp/Data/TodoContext.cs
@@ -0,0 +1,8 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace TodoApp.Data;
+
+public class TodoContext(DbContextOptions<TodoContext> options) : DbContext(options)
+{
+    public DbSet<TodoItem> Items { get; set; } = default!;
+}
diff --git a/test/WebSites/TodoApp/Data/TodoItem.cs b/test/WebSites/TodoApp/Data/TodoItem.cs
new file mode 100644
index 0000000000..f489274091
--- /dev/null
+++ b/test/WebSites/TodoApp/Data/TodoItem.cs
@@ -0,0 +1,14 @@
+namespace TodoApp.Data;
+
+public class TodoItem
+{
+    public Guid Id { get; set; }
+
+    public string Text { get; set; } = default!;
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? CompletedAt { get; set; }
+
+    public int? Priority { get; set; }
+}
diff --git a/test/WebSites/TodoApp/Data/TodoRepository.cs b/test/WebSites/TodoApp/Data/TodoRepository.cs
new file mode 100644
index 0000000000..786b1d6e01
--- /dev/null
+++ b/test/WebSites/TodoApp/Data/TodoRepository.cs
@@ -0,0 +1,124 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace TodoApp.Data;
+
+public class TodoRepository(TimeProvider timeProvider, TodoContext context)
+{
+    public async Task<TodoItem> AddItemAsync(string text, CancellationToken cancellationToken = default)
+    {
+        await EnsureDatabaseAsync(cancellationToken);
+
+        var item = new TodoItem
+        {
+            CreatedAt = UtcNow(),
+            Text = text,
+        };
+
+        context.Add(item);
+
+        await context.SaveChangesAsync(cancellationToken);
+
+        return item;
+    }
+
+    public async Task<bool?> CompleteItemAsync(Guid itemId, CancellationToken cancellationToken = default)
+    {
+        var item = await GetItemAsync(itemId, cancellationToken);
+
+        if (item is null)
+        {
+            return null;
+        }
+
+        if (item.CompletedAt.HasValue)
+        {
+            return false;
+        }
+
+        item.CompletedAt = UtcNow();
+
+        context.Items.Update(item);
+
+        await context.SaveChangesAsync(cancellationToken);
+
+        return true;
+    }
+
+    public async Task<bool> DeleteItemAsync(Guid itemId, CancellationToken cancellationToken = default)
+    {
+        var item = await GetItemAsync(itemId, cancellationToken);
+
+        if (item is null)
+        {
+            return false;
+        }
+
+        context.Items.Remove(item);
+
+        await context.SaveChangesAsync(cancellationToken);
+
+        return true;
+    }
+
+    public async Task<TodoItem?> GetItemAsync(Guid itemId, CancellationToken cancellationToken = default)
+    {
+        await EnsureDatabaseAsync(cancellationToken);
+
+        return await context.Items.FindItemAsync(itemId, cancellationToken);
+    }
+
+    public async Task<IList<TodoItem>> GetItemsAsync(CancellationToken cancellationToken = default)
+    {
+        await EnsureDatabaseAsync(cancellationToken);
+
+        return await context.Items
+            .OrderBy(x => x.CompletedAt.HasValue)
+            .ThenBy(x => x.CreatedAt)
+            .ToListAsync(cancellationToken);
+    }
+
+    public async Task<IList<TodoItem>> FindAsync(
+        string prefix,
+        bool isCompleted,
+        CancellationToken cancellationToken = default)
+    {
+        await EnsureDatabaseAsync(cancellationToken);
+
+        return await context.Items
+            .Where(x => x.Text.StartsWith(prefix))
+            .Where(x => x.CompletedAt.HasValue == isCompleted)
+            .ToListAsync(cancellationToken);
+    }
+
+    public async Task<IList<TodoItem>> GetAfterDateAsync(DateTime value, CancellationToken cancellationToken)
+    {
+        await EnsureDatabaseAsync(cancellationToken);
+
+        return await context.Items
+            .Where(x => x.CreatedAt > value)
+            .ToListAsync(cancellationToken);
+    }
+
+    public async Task<bool> SetPriorityAsync(Guid itemId, int priority, CancellationToken cancellationToken = default)
+    {
+        var item = await GetItemAsync(itemId, cancellationToken);
+
+        if (item is null)
+        {
+            return false;
+        }
+
+        item.Priority = priority;
+
+        context.Items.Update(item);
+
+        await context.SaveChangesAsync(cancellationToken);
+
+        return true;
+    }
+
+    private async Task EnsureDatabaseAsync(CancellationToken cancellationToken)
+        => await context.Database.EnsureCreatedAsync(cancellationToken);
+
+    private DateTime UtcNow() => timeProvider.GetUtcNow().UtcDateTime;
+}
diff --git a/test/WebSites/TodoApp/DbSetExtensions.cs b/test/WebSites/TodoApp/DbSetExtensions.cs
new file mode 100644
index 0000000000..3cbf323f06
--- /dev/null
+++ b/test/WebSites/TodoApp/DbSetExtensions.cs
@@ -0,0 +1,16 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace TodoApp;
+
+public static class DbSetExtensions
+{
+    public static ValueTask<TEntity?> FindItemAsync<TEntity, TKey>(
+        this DbSet<TEntity> set,
+        TKey keyValue,
+        CancellationToken cancellationToken)
+        where TEntity : class
+    {
+        ArgumentNullException.ThrowIfNull(keyValue);
+        return set.FindAsync([keyValue], cancellationToken);
+    }
+}
diff --git a/test/WebSites/TodoApp/Models/CreateTodoItemModel.cs b/test/WebSites/TodoApp/Models/CreateTodoItemModel.cs
new file mode 100644
index 0000000000..0fca50f3f7
--- /dev/null
+++ b/test/WebSites/TodoApp/Models/CreateTodoItemModel.cs
@@ -0,0 +1,12 @@
+namespace TodoApp.Models;
+
+/// <summary>
+/// Represents the model for creating a new Todo item.
+/// </summary>
+public class CreateTodoItemModel
+{
+    /// <summary>
+    /// Gets or sets the text of the Todo item.
+    /// </summary>
+    public string Text { get; set; } = string.Empty;
+}
diff --git a/test/WebSites/TodoApp/Models/CreatedTodoItemModel.cs b/test/WebSites/TodoApp/Models/CreatedTodoItemModel.cs
new file mode 100644
index 0000000000..3433804c96
--- /dev/null
+++ b/test/WebSites/TodoApp/Models/CreatedTodoItemModel.cs
@@ -0,0 +1,12 @@
+namespace TodoApp.Models;
+
+/// <summary>
+/// Represents the model for a created Todo item.
+/// </summary>
+public class CreatedTodoItemModel
+{
+    /// <summary>
+    /// Gets or sets the ID of the created Todo item.
+    /// </summary>
+    public string Id { get; set; } = string.Empty;
+}
diff --git a/test/WebSites/TodoApp/Models/TodoItemFilterModel.cs b/test/WebSites/TodoApp/Models/TodoItemFilterModel.cs
new file mode 100644
index 0000000000..7fcb17151e
--- /dev/null
+++ b/test/WebSites/TodoApp/Models/TodoItemFilterModel.cs
@@ -0,0 +1,17 @@
+namespace TodoApp.Models;
+
+/// <summary>
+/// Represents the model for searching for Todo items.
+/// </summary>
+public class TodoItemFilterModel
+{
+    /// <summary>
+    /// Gets or sets the text of the filter.
+    /// </summary>
+    public string Text { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to search completed Todo items.
+    /// </summary>
+    public bool IsCompleted { get; set; }
+}
diff --git a/test/WebSites/TodoApp/Models/TodoItemModel.cs b/test/WebSites/TodoApp/Models/TodoItemModel.cs
new file mode 100644
index 0000000000..dcfa054f70
--- /dev/null
+++ b/test/WebSites/TodoApp/Models/TodoItemModel.cs
@@ -0,0 +1,37 @@
+namespace TodoApp.Models;
+
+/// <summary>
+/// Represents a Todo item.
+/// </summary>
+public class TodoItemModel
+{
+    /// <summary>
+    /// Gets or sets the ID of the Todo item.
+    /// </summary>
+    public string Id { get; set; } = default!;
+
+    /// <summary>
+    /// Gets or sets the text of the Todo item.
+    /// </summary>
+    public string Text { get; set; } = default!;
+
+    /// <summary>
+    /// Gets or sets the date and time the item was created.
+    /// </summary>
+    public DateTimeOffset CreatedAt { get; set; }
+
+    /// <summary>
+    /// Gets or sets the date and time the item was completed.
+    /// </summary>
+    public DateTimeOffset? CompletedAt { get; set; }
+
+    /// <summary>
+    /// Gets or sets the date and time the Todo item was last updated.
+    /// </summary>
+    public DateTimeOffset LastUpdated { get; set; } = default!;
+
+    /// <summary>
+    /// Gets or sets the optional priority of the Todo item.
+    /// </summary>
+    public TodoPriority? Priority { get; set; }
+}
diff --git a/test/WebSites/TodoApp/Models/TodoListViewModel.cs b/test/WebSites/TodoApp/Models/TodoListViewModel.cs
new file mode 100644
index 0000000000..25d96cef40
--- /dev/null
+++ b/test/WebSites/TodoApp/Models/TodoListViewModel.cs
@@ -0,0 +1,12 @@
+namespace TodoApp.Models;
+
+/// <summary>
+/// Represents a collection of Todo items.
+/// </summary>
+public class TodoListViewModel
+{
+    /// <summary>
+    /// Gets or sets the Todo item(s).
+    /// </summary>
+    public ICollection<TodoItemModel> Items { get; set; } = [];
+}
diff --git a/test/WebSites/TodoApp/Models/TodoPriority.cs b/test/WebSites/TodoApp/Models/TodoPriority.cs
new file mode 100644
index 0000000000..e38af006d6
--- /dev/null
+++ b/test/WebSites/TodoApp/Models/TodoPriority.cs
@@ -0,0 +1,25 @@
+using System.Text.Json.Serialization;
+
+namespace TodoApp.Models;
+
+/// <summary>
+/// The priority levels for a Todo item.
+/// </summary>
+[JsonConverter(typeof(JsonStringEnumConverter<TodoPriority>))]
+public enum TodoPriority
+{
+    /// <summary>
+    /// The item is of normal priority.
+    /// </summary>
+    Normal = 0,
+
+    /// <summary>
+    /// The item is of low priority.
+    /// </summary>
+    Low,
+
+    /// <summary>
+    /// The item is of high priority.
+    /// </summary>
+    High,
+}
diff --git a/test/WebSites/TodoApp/Models/UpdateTodoItemPriorityModel.cs b/test/WebSites/TodoApp/Models/UpdateTodoItemPriorityModel.cs
new file mode 100644
index 0000000000..9ec8faae8f
--- /dev/null
+++ b/test/WebSites/TodoApp/Models/UpdateTodoItemPriorityModel.cs
@@ -0,0 +1,12 @@
+namespace TodoApp.Models;
+
+/// <summary>
+/// Represents the model for updating the priority of a Todo item.
+/// </summary>
+public class UpdateTodoItemPriorityModel
+{
+    /// <summary>
+    /// Gets or sets the new priority of the Todo item.
+    /// </summary>
+    public TodoPriority Priority { get; set; }
+}
diff --git a/test/WebSites/TodoApp/Program.cs b/test/WebSites/TodoApp/Program.cs
new file mode 100644
index 0000000000..36aa2aff5c
--- /dev/null
+++ b/test/WebSites/TodoApp/Program.cs
@@ -0,0 +1,19 @@
+using TodoApp;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.AddTodoApp();
+
+var app = builder.Build();
+
+app.UseTodoApp();
+
+app.Run();
+
+namespace TodoApp
+{
+    public partial class Program
+    {
+        // Expose the Program class for use with WebApplicationFactory<T>
+    }
+}
diff --git a/test/WebSites/TodoApp/Properties/launchSettings.json b/test/WebSites/TodoApp/Properties/launchSettings.json
new file mode 100644
index 0000000000..be95968c5c
--- /dev/null
+++ b/test/WebSites/TodoApp/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "TodoApp": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:5916;http://localhost:5618",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}
diff --git a/test/WebSites/TodoApp/TodoApp.csproj b/test/WebSites/TodoApp/TodoApp.csproj
new file mode 100644
index 0000000000..93a1f779b2
--- /dev/null
+++ b/test/WebSites/TodoApp/TodoApp.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <PropertyGroup>
+    <EnableConfigurationBindingGenerator>true</EnableConfigurationBindingGenerator>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <IsAotCompatible>false</IsAotCompatible>
+    <IsPackable>false</IsPackable>
+    <NoWarn>$(NoWarn);CA1019;CA1050;CA1813;CS1591;IDE0130</NoWarn>
+    <Nullable>enable</Nullable>
+    <RootNamespace>TodoApp</RootNamespace>
+    <TargetFrameworks>$(DefaultTargetFrameworks)</TargetFrameworks>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\src\Swashbuckle.AspNetCore.Annotations\Swashbuckle.AspNetCore.Annotations.csproj" />
+    <ProjectReference Include="..\..\..\src\Swashbuckle.AspNetCore.SwaggerUI\Swashbuckle.AspNetCore.SwaggerUI.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" VersionOverride="8.0.22" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" VersionOverride="9.0.11" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net10.0'">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" VersionOverride="10.0.0" />
+  </ItemGroup>
+</Project>
diff --git a/test/WebSites/TodoApp/TodoAppBuilder.cs b/test/WebSites/TodoApp/TodoAppBuilder.cs
new file mode 100644
index 0000000000..dd32971322
--- /dev/null
+++ b/test/WebSites/TodoApp/TodoAppBuilder.cs
@@ -0,0 +1,56 @@
+using System.Reflection;
+using Microsoft.AspNetCore.WebUtilities;
+
+namespace TodoApp;
+
+public static class TodoAppBuilder
+{
+    public static WebApplicationBuilder AddTodoApp(this WebApplicationBuilder builder)
+    {
+        builder.Services.AddTodoApi();
+
+        builder.Services.AddEndpointsApiExplorer();
+        builder.Services.AddSwaggerGen((options) =>
+        {
+            options.EnableAnnotations();
+            options.IncludeXmlComments(Assembly.GetExecutingAssembly());
+            options.SupportNonNullableReferenceTypes();
+            options.UseAllOfToExtendReferenceSchemas();
+
+            var version = "v1";
+            options.SwaggerDoc(version, new() { Title = "Todo API", Version = version });
+        });
+
+        if (!builder.Environment.IsDevelopment())
+        {
+            builder.Services.AddProblemDetails();
+            builder.Services.Configure<ProblemDetailsOptions>((options) =>
+            {
+                options.CustomizeProblemDetails = (context) =>
+                {
+                    if (context.Exception is not null)
+                    {
+                        context.ProblemDetails.Detail = "An internal error occurred.";
+                    }
+
+                    context.ProblemDetails.Instance = context.HttpContext.Request.Path;
+                    context.ProblemDetails.Title = ReasonPhrases.GetReasonPhrase(context.ProblemDetails.Status ?? StatusCodes.Status500InternalServerError);
+                };
+            });
+        }
+
+        return builder;
+    }
+
+    public static WebApplication UseTodoApp(this WebApplication app)
+    {
+        app.UseStatusCodePagesWithReExecute("/error", "?id={0}");
+
+        app.MapTodoApiRoutes();
+
+        app.UseSwagger((p) => p.OpenApiVersion = Microsoft.OpenApi.OpenApiSpecVersion.OpenApi3_0);
+        app.UseSwaggerUI();
+
+        return app;
+    }
+}
diff --git a/test/WebSites/TodoApp/TodoJsonSerializerContext.cs b/test/WebSites/TodoApp/TodoJsonSerializerContext.cs
new file mode 100644
index 0000000000..52f8b270e0
--- /dev/null
+++ b/test/WebSites/TodoApp/TodoJsonSerializerContext.cs
@@ -0,0 +1,25 @@
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+using Microsoft.AspNetCore.Mvc;
+using TodoApp.Models;
+
+namespace TodoApp;
+
+[JsonSerializable(typeof(CreateTodoItemModel))]
+[JsonSerializable(typeof(CreatedTodoItemModel))]
+[JsonSerializable(typeof(DateTime))]
+[JsonSerializable(typeof(Guid))]
+[JsonSerializable(typeof(JsonObject))]
+[JsonSerializable(typeof(ProblemDetails))]
+[JsonSerializable(typeof(TodoItemFilterModel))]
+[JsonSerializable(typeof(TodoItemModel))]
+[JsonSerializable(typeof(TodoListViewModel))]
+[JsonSerializable(typeof(TodoPriority))]
+[JsonSerializable(typeof(UpdateTodoItemPriorityModel))]
+[JsonSourceGenerationOptions(
+    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+    NumberHandling = JsonNumberHandling.Strict,
+    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
+    UseStringEnumConverter = true,
+    WriteIndented = true)]
+public sealed partial class TodoJsonSerializerContext : JsonSerializerContext;
diff --git a/test/WebSites/TodoApp/TodoService.cs b/test/WebSites/TodoApp/TodoService.cs
new file mode 100644
index 0000000000..9115ff7fcf
--- /dev/null
+++ b/test/WebSites/TodoApp/TodoService.cs
@@ -0,0 +1,77 @@
+using TodoApp.Data;
+using TodoApp.Models;
+
+namespace TodoApp;
+
+public class TodoService(TodoRepository repository)
+{
+    public async Task<string> AddItemAsync(string text, CancellationToken cancellationToken)
+    {
+        var item = await repository.AddItemAsync(text, cancellationToken);
+        return item.Id.ToString();
+    }
+
+    public async Task<bool?> CompleteItemAsync(Guid itemId, CancellationToken cancellationToken)
+    {
+        return await repository.CompleteItemAsync(itemId, cancellationToken);
+    }
+
+    public async Task<bool> DeleteItemAsync(Guid itemId, CancellationToken cancellationToken)
+    {
+        return await repository.DeleteItemAsync(itemId, cancellationToken);
+    }
+
+    public async Task<TodoItemModel?> GetAsync(Guid itemId, CancellationToken cancellationToken)
+    {
+        var item = await repository.GetItemAsync(itemId, cancellationToken);
+        return item is null ? null : MapItem(item);
+    }
+
+    public async Task<TodoListViewModel> GetListAsync(CancellationToken cancellationToken)
+    {
+        var items = await repository.GetItemsAsync(cancellationToken);
+        return MapItems(items);
+    }
+
+    public async Task<TodoListViewModel> FindAsync(TodoItemFilterModel filter, CancellationToken cancellationToken)
+    {
+        var items = await repository.FindAsync(filter.Text, filter.IsCompleted, cancellationToken);
+        return MapItems(items);
+    }
+
+    public async Task<TodoListViewModel> GetAfterDateAsync(DateTime value, CancellationToken cancellationToken)
+    {
+        var items = await repository.GetAfterDateAsync(value, cancellationToken);
+        return MapItems(items);
+    }
+
+    public async Task<bool> SetPriorityAsync(Guid itemId, TodoPriority priority, CancellationToken cancellationToken)
+    {
+        return await repository.SetPriorityAsync(itemId, (int)priority, cancellationToken);
+    }
+
+    private static TodoListViewModel MapItems(IList<TodoItem> items)
+    {
+        var result = new List<TodoItemModel>(items.Count);
+
+        foreach (var todo in items)
+        {
+            result.Add(MapItem(todo));
+        }
+
+        return new() { Items = result };
+    }
+
+    private static TodoItemModel MapItem(TodoItem item)
+    {
+        return new()
+        {
+            Id = item.Id.ToString(),
+            CompletedAt = item.CompletedAt,
+            CreatedAt = item.CreatedAt,
+            LastUpdated = item.CompletedAt ?? item.CreatedAt,
+            Priority = item.Priority is { } priority ? (TodoPriority)priority : null,
+            Text = item.Text,
+        };
+    }
+}
diff --git a/test/WebSites/TodoApp/appsettings.Development.json b/test/WebSites/TodoApp/appsettings.Development.json
new file mode 100644
index 0000000000..e62a4a3e26
--- /dev/null
+++ b/test/WebSites/TodoApp/appsettings.Development.json
@@ -0,0 +1,10 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug",
+      "System": "Warning",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}
diff --git a/test/WebSites/TodoApp/appsettings.json b/test/WebSites/TodoApp/appsettings.json
new file mode 100644
index 0000000000..def9159a7d
--- /dev/null
+++ b/test/WebSites/TodoApp/appsettings.json
@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}