public string GenerateCode(OutputType type)
        {
            using var codeBuilder = new IndentedStringBuilder(_options.IndentSize);

            // Import classes
            var importStrings = _generator.GenerateImportStrings(type);

            foreach (var importString in importStrings)
            {
                codeBuilder.AppendLine(importString);
            }

            if (importStrings.Length > 0)
            {
                codeBuilder.AppendLine();
            }

            // Type definition
            using var resultBuilder = type switch
                  {
                      Types.Enum enumType => GenerateEnumCode(codeBuilder, enumType),
                      _ => GenerateTypeCode(codeBuilder, type),
                  };

            return(resultBuilder.ToString());
        }
        protected virtual IndentedStringBuilder GenerateEnumCode(IndentedStringBuilder codeBuilder, Types.Enum type)
        {
            codeBuilder.AppendLine($"export enum {_generator.GenerateName(type.Name)} {{");
            using (codeBuilder.Indent())
            {
                var currentEnumValue = 0;

                foreach (var enumValue in type.EnumValues)
                {
                    string enumString;

                    if (currentEnumValue != enumValue.Value)
                    {
                        currentEnumValue = enumValue.Value;
                        enumString       = $"{enumValue.Key} = {currentEnumValue}";
                    }
                    else
                    {
                        enumString = enumValue.Key;
                    }

                    currentEnumValue++;
                    if (enumValue.Key != type.EnumValues.Last().Key)
                    {
                        enumString += ",";
                    }

                    codeBuilder.AppendLine(enumString);
                }
            }
            codeBuilder.Append("}");

            return(codeBuilder);
        }