VSCode allowedValues Output string literal Union type - Asking for enum

[damntrecky]

Is your feature request related to a problem? Please describe.
The current VSCode allowedValues outputs a string literal union type in Typescript:

export type LambdaRuntime = 'dotnetcore2.1' | 'nodejs12.x'

The other implementations for Kotlin and C# output an enum type. The Typescript code standard in PR's keep asking for Enums as the preferred implementation, so we are converting the String literal Union types output from this package to hardcoded Enums... This process seems backwards.

Describe the solution you'd like
I would like the Typescript allowedValues to ouput an Enum type

export  enum LambdaRuntime{
    Dotnetcore21 = 'dotnetcore2.1',
    Nodejs12x = 'nodejs12.x'
}

Describe alternatives you've considered
I have not

Additional context

Kotlin output for enum

/**
 * The lambda runtime
 */
public enum class LambdaRuntime(
    private val `value`: String,
) {
    Dotnetcore21("dotnetcore2.1"),
    Nodejs12x("nodejs12.x"),
    Unknown("unknown"),
    ;

    public override fun toString(): String = value

    public companion object {
        public fun from(type: String): LambdaRuntime = values().firstOrNull { it.value == type }
                ?: Unknown
    }
}

All code snippets referenced from test files generatorOutput.ts and testGeneratorOutput for Kotlin and Typescript within this package.

[damntrecky]

If this works and is accepted, it would be a breaking change and not backwards compatible. So for that reason, it may not be possible to make this update.

[damntrecky]

The Typescript string literal type definition says:

In practice string literal types combine nicely with union types, type guards, and type aliases. You can use these features together to get enum-like behavior with strings.

Which I think works fine. We keep getting comments on poor implementation for allowedValues and should use Enum types as its the "preferred standard" for reviewers.

I would expect consistency in the implementation here across languages, if possible.

[justinmk3]

The Typescript code standard in PR's keep asking for Enums as the preferred implementation

What standard is requesting that? Enums in typescript are rarely, if ever, needed. Union types can be made "iterable", see https://stackoverflow.com/a/60041791/152142

Typescript string literal type definition says:

In practice string literal types combine nicely with union types, type guards, and type aliases. You can use these features together to get enum-like behavior with strings.

Which I think works fine. We keep getting comments on poor implementation for allowedValues

We can enhance telemetry generator to generate iterable names for the union types.