Remove Class Name Prefix from Nested Classes

src/Kiota.Builder/KiotaBuilder.cs

@@ -1412,7 +1412,7 @@ internal static void AddSerializationMembers(CodeClass model, bool includeAdditi
     }
     private CodeClass CreateOperationParameterClass(OpenApiUrlTreeNode node, OperationType operationType, OpenApiOperation operation, CodeClass parentClass)
     {
-        var parameters = node.PathItems[Constants.DefaultOpenApiLabel].Parameters.Union(operation.Parameters).Where(p => p.In == ParameterLocation.Query);
+        var parameters = node.PathItems[Constants.DefaultOpenApiLabel].Parameters.Union(operation.Parameters).Where(static p => p.In == ParameterLocation.Query);
         if(parameters.Any()) {
             var parameterClass = parentClass.AddInnerClass(new CodeClass
             {

src/Kiota.Builder/Refiners/CSharpRefiner.cs

@@ -25,7 +25,6 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance
             AddRawUrlConstructorOverload(generatedCode);
             AddPropertiesAndMethodTypesImports(generatedCode, false, false, false);
             AddAsyncSuffix(generatedCode);
-            AddInnerClasses(generatedCode, false, string.Empty);
             cancellationToken.ThrowIfCancellationRequested();
             AddParsableImplementsForModelClasses(generatedCode, "IParsable");
             CapitalizeNamespacesFirstLetters(generatedCode);

src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs

@@ -475,7 +475,7 @@ internal void DisableActionOf(CodeElement current, params CodeParameterKind[] ki
         CrawlTree(current, x => DisableActionOf(x, kinds));
     }
     internal void AddInnerClasses(CodeElement current, bool prefixClassNameWithParentName, string queryParametersBaseClassName = "", bool addToParentNamespace = false) {
-        if(current is CodeClass currentClass) {
+        if(current is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.RequestBuilder)) {
             var parentNamespace = currentClass.GetImmediateParentOfType<CodeNamespace>();
             var innerClasses = currentClass
                                     .Methods

src/Kiota.Builder/Refiners/GoRefiner.cs

@@ -20,8 +20,7 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance
             cancellationToken.ThrowIfCancellationRequested();
             AddInnerClasses(
                 generatedCode,
-                true,
-                null);
+                true);
             ReplaceIndexersByMethodsWithParameter(
                 generatedCode,
                 generatedCode,

src/Kiota.Builder/Refiners/JavaRefiner.cs

@@ -17,7 +17,7 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance
         return Task.Run(() => {
             cancellationToken.ThrowIfCancellationRequested();
             LowerCaseNamespaceNames(generatedCode);
-            AddInnerClasses(generatedCode, false, string.Empty);
+            RemoveClassNamePrefixFromNestedClasses(generatedCode);
             InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(generatedCode);
             ReplaceIndexersByMethodsWithParameter(generatedCode, generatedCode, true);
             cancellationToken.ThrowIfCancellationRequested();
@@ -298,9 +298,70 @@ private void InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors(C
 
         CrawlTree(currentElement, InsertOverrideMethodForRequestExecutorsAndBuildersAndConstructors);
     }
+    private static void RemoveClassNamePrefixFromNestedClasses(CodeElement currentElement) {
+        if(currentElement is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.RequestBuilder)) {
+            var prefix = currentClass.Name;
+            var innerClasses = currentClass
+                                    .Methods
+                                    .SelectMany(static x => x.Parameters)
+                                    .Where(static x => x.Type.ActionOf && x.IsOfKind(CodeParameterKind.RequestConfiguration))
+                                    .SelectMany(static x => x.Type.AllTypes)
+                                    .Select(static x => x.TypeDefinition)
+                                    .OfType<CodeClass>();
 
-    // Namespaces in Java by convention are all lower case, like:
-    // com.microsoft.kiota.serialization
+            // ensure we do not miss out the types present in request configuration objects i.e. the query parameters
+            var nestedQueryParameters = innerClasses
+                                    .SelectMany(static x => x.Properties)
+                                    .Where(static x => x.IsOfKind(CodePropertyKind.QueryParameters))
+                                    .SelectMany(static x => x.Type.AllTypes)
+                                    .Select(static x => x.TypeDefinition)
+                                    .OfType<CodeClass>();
+
+            var nestedClasses = new List<CodeClass>();
+            nestedClasses.AddRange(innerClasses);
+            nestedClasses.AddRange(nestedQueryParameters);
+
+            foreach(var innerClass in nestedClasses) {
+                if(innerClass.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 
+                    innerClass.Name = innerClass.Name[prefix.Length..];
+
+                if(innerClass.IsOfKind(CodeClassKind.RequestConfiguration))
+                    RemovePrefixFromQueryProperties(innerClass, prefix);
+            }
+            RemovePrefixFromRequestConfigParameters(currentClass, prefix);
+        }
+        CrawlTree(currentElement, x => RemoveClassNamePrefixFromNestedClasses(x));
+    }
+    private static void RemovePrefixFromQueryProperties(CodeElement currentElement, String prefix) { 
+        if(currentElement is CodeClass currentClass) {            
+            var queryProperty = currentClass
+                                .Properties
+                                .Where(static x=> x.IsOfKind(CodePropertyKind.QueryParameters))
+                                .Select(static x => x.Type)
+                                .OfType<CodeTypeBase>()
+                                .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
+
+            foreach(var property in queryProperty) {
+                property.Name = property.Name[prefix.Length..];
+            }
+        }
+    }
+    private static void RemovePrefixFromRequestConfigParameters(CodeElement currentElement, String prefix) {
+        if(currentElement is CodeClass currentClass) {
+            var parameters = currentClass
+                                .Methods
+                                .SelectMany(static x => x.Parameters)
+                                .Where(static x => x.Type.ActionOf && x.IsOfKind(CodeParameterKind.RequestConfiguration))
+                                .Select(static x=> x.Type)
+                                .OfType<CodeTypeBase>()
+                                .Where(x => x.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
+
+
+            foreach(var parameter in parameters) {
+                parameter.Name = parameter.Name[prefix.Length..];
+            }
+        }
+    }
     private static void LowerCaseNamespaceNames(CodeElement currentElement) {
         if (currentElement is CodeNamespace codeNamespace)
         {

src/Kiota.Builder/Refiners/ShellRefiner.cs

@@ -25,7 +25,6 @@ public override Task Refine(CodeNamespace generatedCode, CancellationToken cance
             );
             AddPropertiesAndMethodTypesImports(generatedCode, false, false, false);
             cancellationToken.ThrowIfCancellationRequested();
-            AddInnerClasses(generatedCode, false);
             AddParsableImplementsForModelClasses(generatedCode, "IParsable");
             CapitalizeNamespacesFirstLetters(generatedCode);
             cancellationToken.ThrowIfCancellationRequested();

tests/Kiota.Builder.Tests/Refiners/GoLanguageRefinerTests.cs

@@ -12,6 +12,34 @@ public class GoLanguageRefinerTests {
     private readonly CodeNamespace root = CodeNamespace.InitRootNamespace();
     #region CommonLangRefinerTests
     [Fact]
+    public async Task AddsInnerClasses() {
+        var model = root.AddClass(new CodeClass {
+            Name = "model",
+            Kind = CodeClassKind.RequestBuilder
+        }).First();
+        var method = model.AddMethod(new CodeMethod {
+            Name = "method1",
+            ReturnType = new CodeType {
+                Name = "string",
+                IsExternal = true
+            }
+        }).First();
+        var parameter = new CodeParameter {
+            Name = "param1",
+            Kind = CodeParameterKind.RequestConfiguration,
+            Type = new CodeType {
+                Name = "SomeCustomType",
+                ActionOf = true,
+                TypeDefinition = new CodeClass {
+                    Name = "SomeCustomType"
+                }
+            }
+        };
+        method.AddParameter(parameter);
+        await ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Go }, root);
+        Assert.Equal(2, model.GetChildElements(true).Count());
+    }
+    [Fact]
     public async Task TrimsCircularDiscriminatorReferences() {
         var modelsNS = root.AddNamespace("models");
         var baseModel = modelsNS.AddClass(new CodeClass {

tests/Kiota.Builder.Tests/Refiners/JavaLanguageRefinerTests.cs

@@ -253,34 +253,6 @@ public async Task ReplacesIndexersByMethodsWithParameter() {
         Assert.Single(collectionRequestBuilder.Properties);
     }
     [Fact]
-    public async Task AddsInnerClasses() {
-        var model = root.AddClass(new CodeClass {
-            Name = "model",
-            Kind = CodeClassKind.Model
-        }).First();
-        var method = model.AddMethod(new CodeMethod {
-            Name = "method1",
-            ReturnType = new CodeType {
-                Name = "string",
-                IsExternal = true
-            }
-        }).First();
-        var parameter = new CodeParameter {
-            Name = "param1",
-            Kind = CodeParameterKind.RequestConfiguration,
-            Type = new CodeType {
-                Name = "SomeCustomType",
-                ActionOf = true,
-                TypeDefinition = new CodeClass {
-                    Name = "SomeCustomType"
-                }
-            }
-        };
-        method.AddParameter(parameter);
-        await ILanguageRefiner.Refine(new GenerationConfiguration { Language = GenerationLanguage.Java }, root);
-        Assert.Equal(2, model.GetChildElements(true).Count());
-    }
-    [Fact]
     public async Task DoesNotKeepCancellationParametersInRequestExecutors()
     {
         var model = root.AddClass(new CodeClass