Review feedback

- Rename `--class-access-modifier` to `--type-access-modifier`.
- Use `AccessModifier` enum instead of string and extend to `Internal` value.
- Add `Access` property to `CodeClass` and `CodeEnum`.
- Use `CSharpRefiner` to set `Access` property from configuration.
- Extend `CodeClassDeclarationWriter` and `CodeEnumWriter` to write actual type access modifier.

Author: NKnusperer

CHANGELOG.md

@@ -23,7 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added the ability to export the CodeDom to a file showing the public APIs to be generated in a given language [#4627](https://github.com/microsoft/kiota/issues/4627)
 - Added composed type serialization in Typescript [2462](https://github.com/microsoft/kiota/issues/2462)
 - Use authentication information available in the source OpenAPI document when generating a plugin manifest. [#5070](https://github.com/microsoft/kiota/issues/5070)
-- Control generated class access modifier for C# via `--class-access-modifier` flag. [#4788](https://github.com/microsoft/kiota/issues/4788)
+- Control generated type access modifier for C# via `--type-access-modifier` flag. [#4788](https://github.com/microsoft/kiota/issues/4788)
 
 ### Changed
 

src/Kiota.Builder/CodeDOM/AccessModifier.cs

@@ -1,6 +1,7 @@
 namespace Kiota.Builder.CodeDOM;
 public enum AccessModifier
 {
+    Internal = 3,
     Public = 2,
     Protected = 1,
     Private = 0

src/Kiota.Builder/CodeDOM/CodeClass.cs

@@ -33,6 +33,9 @@ public enum CodeClassKind
 public class CodeClass : ProprietableBlock<CodeClassKind, ClassDeclaration>, ITypeDefinition, IDiscriminatorInformationHolder, IDeprecableElement
 {
     private readonly ConcurrentDictionary<string, CodeProperty> PropertiesByWireName = new(StringComparer.OrdinalIgnoreCase);
+    
+    public AccessModifier Access { get; set; } = AccessModifier.Public;
+
     public bool IsErrorDefinition
     {
         get; set;

src/Kiota.Builder/CodeDOM/CodeEnum.cs

@@ -8,6 +8,7 @@ namespace Kiota.Builder.CodeDOM;
 public class CodeEnum : CodeBlock<BlockDeclaration, BlockEnd>, IDocumentedElement, ITypeDefinition, IDeprecableElement
 {
 #pragma warning restore CA2227
+    public AccessModifier Access { get; set; } = AccessModifier.Public;
     public bool Flags
     {
         get; set;

src/Kiota.Builder/Configuration/GenerationConfiguration.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Linq;
 using System.Text.Json.Nodes;
+using Kiota.Builder.CodeDOM;
 using Kiota.Builder.Extensions;
 using Kiota.Builder.Lock;
 using Microsoft.OpenApi.ApiManifest;
@@ -38,7 +39,7 @@ public ConsumerOperation? Operation
     public string ApiManifestPath { get; set; } = "apimanifest.json";
     public string OutputPath { get; set; } = "./output";
     public string ClientClassName { get; set; } = "ApiClient";
-    public string? ClientClassAccessModifier { get; set; }
+    public AccessModifier TypeAccessModifier { get; set; } = AccessModifier.Public;
     public string ClientNamespaceName { get; set; } = "ApiSdk";
     public string NamespaceNameSeparator { get; set; } = ".";
     public bool ExportPublicApi

src/Kiota.Builder/KiotaBuilder.cs

@@ -579,7 +579,7 @@ public async Task ApplyLanguageRefinementAsync(GenerationConfiguration config, C
 
     public async Task CreateLanguageSourceFilesAsync(GenerationLanguage language, CodeNamespace generatedCode, CancellationToken cancellationToken)
     {
-        var languageWriter = LanguageWriter.GetLanguageWriter(language, config.OutputPath, config.ClientNamespaceName, config.ClientClassAccessModifier, config.UsesBackingStore, config.ExcludeBackwardCompatible);
+        var languageWriter = LanguageWriter.GetLanguageWriter(language, config.OutputPath, config.ClientNamespaceName, config.UsesBackingStore, config.ExcludeBackwardCompatible);
         var stopwatch = new Stopwatch();
         stopwatch.Start();
         var codeRenderer = CodeRenderer.GetCodeRender(config);

src/Kiota.Builder/Lock/KiotaLock.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Kiota.Builder.CodeDOM;
 using Kiota.Builder.Configuration;
 
 namespace Kiota.Builder.Lock;
@@ -31,9 +32,9 @@ public class KiotaLock
     /// </summary>
     public string ClientClassName { get; set; } = string.Empty;
     /// <summary>
-    /// The class access modifier to use for the client classes.
+    /// The type access modifier to use for the client types.
     /// </summary>
-    public string? ClientClassAccessModifier { get; set; }
+    public string TypeAccessModifier { get; set; } = string.Empty;
     /// <summary>
     /// The main namespace for this client.
     /// </summary>
@@ -106,10 +107,11 @@ public void UpdateGenerationConfigurationFromLock(GenerationConfiguration config
     {
         ArgumentNullException.ThrowIfNull(config);
         config.ClientClassName = ClientClassName;
-        config.ClientClassAccessModifier = ClientClassAccessModifier;
-        config.ClientNamespaceName = ClientNamespaceName;
         if (Enum.TryParse<GenerationLanguage>(Language, out var parsedLanguage))
             config.Language = parsedLanguage;
+        config.ClientNamespaceName = ClientNamespaceName;
+        if (Enum.TryParse<AccessModifier>(TypeAccessModifier, out var parsedAccessModifier))
+            config.TypeAccessModifier = parsedAccessModifier;
         config.UsesBackingStore = UsesBackingStore;
         config.ExcludeBackwardCompatible = ExcludeBackwardCompatible;
         config.IncludeAdditionalData = IncludeAdditionalData;
@@ -137,7 +139,7 @@ public KiotaLock(GenerationConfiguration config)
         ArgumentNullException.ThrowIfNull(config);
         Language = config.Language.ToString();
         ClientClassName = config.ClientClassName;
-        ClientClassAccessModifier = config.ClientClassAccessModifier;
+        TypeAccessModifier = config.TypeAccessModifier.ToString();
         ClientNamespaceName = config.ClientNamespaceName;
         UsesBackingStore = config.UsesBackingStore;
         ExcludeBackwardCompatible = config.ExcludeBackwardCompatible;

src/Kiota.Builder/Refiners/CSharpRefiner.cs

@@ -110,6 +110,7 @@ public override Task RefineAsync(CodeNamespace generatedCode, CancellationToken
                 generatedCode,
                 "IParseNode"
             );
+            SetTypeAccessModifiers(generatedCode);
         }, cancellationToken);
     }
     protected static void DisambiguatePropertiesWithClassNames(CodeElement currentElement)
@@ -260,4 +261,19 @@ protected static void CorrectIndexerType(CodeIndexer currentIndexer)
                 })
         },
     };
+
+    private void SetTypeAccessModifiers(CodeElement currentElement)
+    {
+        switch (currentElement)
+        {
+            case CodeClass currentClass:
+                currentClass.Access = _configuration.TypeAccessModifier;
+                break;
+            case CodeEnum currentEnum:
+                currentEnum.Access = _configuration.TypeAccessModifier;
+                break;
+        }
+
+        CrawlTree(currentElement, SetTypeAccessModifiers);
+    }
 }

src/Kiota.Builder/Writers/CLI/CliWriter.cs

@@ -3,10 +3,10 @@
 namespace Kiota.Builder.Writers.Cli;
 class CliWriter : CSharpWriter
 {
-    public CliWriter(string rootPath, string clientNamespaceName, string? clientClassAccessModifier) : base(rootPath, clientNamespaceName, clientClassAccessModifier)
+    public CliWriter(string rootPath, string clientNamespaceName) : base(rootPath, clientNamespaceName)
     {
         var conventionService = new CSharpConventionService();
-        AddOrReplaceCodeElementWriter(new CodeClassDeclarationWriter(conventionService, clientClassAccessModifier));
+        AddOrReplaceCodeElementWriter(new CodeClassDeclarationWriter(conventionService));
         AddOrReplaceCodeElementWriter(new CodeBlockEndWriter(conventionService));
         AddOrReplaceCodeElementWriter(new CodeEnumWriter(conventionService));
         AddOrReplaceCodeElementWriter(new CodeIndexerWriter(conventionService));

src/Kiota.Builder/Writers/CSharp/CSharpConventionService.cs

@@ -96,6 +96,7 @@ public override string GetAccessModifier(AccessModifier access)
     {
         return access switch
         {
+            AccessModifier.Internal => "internal",
             AccessModifier.Public => "public",
             AccessModifier.Protected => "protected",
             _ => "private",