Preserve empty string enum values during generation

src/Kiota.Builder/CodeDOM/CodeEnumOption.cs

@@ -5,18 +5,30 @@ namespace Kiota.Builder.CodeDOM;
 public class CodeEnumOption : CodeElement, IDocumentedElement, ITypeDefinition, IAlternativeName
 {
     /// <inheritdoc/>
-    public string SerializationName { get; set; } = string.Empty;
+    public string SerializationName
+    {
+        get => serializationName;
+        set
+        {
+            serializationName = value ?? string.Empty;
+            hasSerializationName = true;
+        }
+    }
+    private string serializationName = string.Empty;
+    private bool hasSerializationName;
     public CodeDocumentation Documentation { get; set; } = new();
     /// <inheritdoc/>
     public bool IsNameEscaped
     {
-        get => !string.IsNullOrEmpty(SerializationName);
+        get => hasSerializationName;
     }
     /// <inheritdoc/>
     public string WireName => IsNameEscaped ? SerializationName : Name;
     /// <inheritdoc/>
     public string SymbolName
     {
-        get => IsNameEscaped ? SerializationName.CleanupSymbolName() : Name;
+        get => IsNameEscaped && !string.IsNullOrEmpty(SerializationName) ?
+            SerializationName.CleanupSymbolName() :
+            Name;
     }
 }

src/Kiota.Builder/KiotaBuilder.cs

@@ -2195,16 +2195,16 @@ private static void SetEnumOptions(IOpenApiSchema schema, CodeEnum target)
         target.AddOption(schema.Enum?.OfType<JsonValue>()
                         .Where(static x => x.GetValueKind() is JsonValueKind.String or JsonValueKind.Number)
                         .Select(static x => x.GetValueKind() is JsonValueKind.String ? x.GetValue<string>() : x.GetValue<decimal>().ToString(CultureInfo.InvariantCulture))
-                        .Where(static x => !string.IsNullOrEmpty(x))
                         .Distinct(StringComparer.OrdinalIgnoreCase)
                         .Select((x) =>
                         {
                             var optionDescription = extensionInformation?.ValuesDescriptions.Find(y => y.Value.Equals(x, StringComparison.OrdinalIgnoreCase));
+                            var optionName = optionDescription?.Name is string name && !string.IsNullOrEmpty(name) ?
+                                name :
+                                string.IsNullOrEmpty(x) ? "Empty" : x;
                             return new CodeEnumOption
                             {
-                                Name = (optionDescription?.Name is string name && !string.IsNullOrEmpty(name) ?
-                                        name :
-                                        x).CleanupSymbolName(),
+                                Name = optionName.CleanupSymbolName(),
                                 SerializationName = x,
                                 Documentation = new()
                                 {

tests/Kiota.Builder.Tests/CodeDOM/CodeEnumTests.cs

@@ -23,4 +23,18 @@ public void EnumInits()
         }).First();
         codeEnum.AddOption(new CodeEnumOption { Name = "option1" });
     }
+
+    [Fact]
+    public void PreservesExplicitEmptySerializationName()
+    {
+        var option = new CodeEnumOption
+        {
+            Name = "Empty",
+            SerializationName = string.Empty,
+        };
+
+        Assert.True(option.IsNameEscaped);
+        Assert.Empty(option.WireName);
+        Assert.Equal("Empty", option.SymbolName);
+    }
 }

tests/Kiota.Builder.Tests/KiotaBuilderTests.cs

@@ -530,6 +530,7 @@ public async Task ParsesEnumDescriptionsAsync()
         - Standard_RAGRS
         - Premium_LRS
         - Premium_LRS
+        - ''
       x-ms-enum:
         name: AccountType
         modelAsString: false
@@ -568,6 +569,9 @@ public async Task ParsesEnumDescriptionsAsync()
         Assert.Equal("StandardLocalRedundancy", thirdOption.Name);
         Assert.NotEmpty(thirdOption.Documentation.DescriptionTemplate);
         Assert.Single(enumDef.Options, static x => x.Name.Equals("Premium_LRS", StringComparison.OrdinalIgnoreCase));
+        var emptyOption = Assert.Single(enumDef.Options, static x => x.Name.Equals("Empty", StringComparison.OrdinalIgnoreCase));
+        Assert.Empty(emptyOption.SerializationName);
+        Assert.Empty(emptyOption.WireName);
     }
 
     [Fact]

tests/Kiota.Builder.Tests/Writers/Go/CodeEnumWriterTests.cs

@@ -232,4 +232,19 @@ public void EscapesEnumWireValues()
         Assert.Contains("return []string{\"line1\\\"\\nline2\"}[i]", result);
         Assert.Contains("case \"line1\\\"\\nline2\":", result);
     }
+
+    [Fact]
+    public void WritesEmptyEnumWireValue()
+    {
+        currentEnum.AddOption(
+            new CodeEnumOption { Name = "option1" },
+            new CodeEnumOption { Name = "empty", SerializationName = string.Empty });
+
+        writer.Write(currentEnum);
+        var result = tw.ToString();
+
+        Assert.Contains("return []string{\"option1\", \"\"}[i]", result);
+        Assert.Contains("case \"\":", result);
+        Assert.Contains("result = EMPTY_SOMEENUM", result);
+    }
 }