If you have string enum like so:

export enum LookingForEnum {
    Romantic = 'Romantic relationship',
    Casual = 'Casual relationship',
    Friends = 'Friends',
    Fun = 'Fun things to do!'
}

Then

 const index: number = Object.keys(LookingForEnum).indexOf('Casual'); // 1

Enums in TypeScript 0.9 are string+number based. You should not need type assertion for simple conversions:

enum Color{
    Red, Green
}

// To String
 var green: string = Color[Color.Green];

// To Enum / number
var color : Color = Color[green];

Try it online

I have documentation about this and other Enum patterns in my OSS book : https://basarat.gitbook.io/typescript/type-system/enums

Make sure to use this if you are using the typescript flag --noImplicitAny:

var color : Color = Color[green as keyof typeof Color];

1. |undefined does not make a property optional, just means it can be undefined, there is a proposal to make |undefined members optional but currently it's not implemented. You need to use ? after ] to make all properties optional

   { [key in DialogType]?: Dialog }
   

2. You can use the dialog enum values as keys, but they need to be computed properties:

   let openDialogs: { [key in DialogType]?: Dialog } = {
       [DialogType.Options]: undefined,
   };
   

3. { [key: number or string]: Dialog } is an index signature. Index signatures are restricted to only number or string as the key type (not even a union of the two will work). So if you use an index signature you can index by any number or string (we can't restrict to only DialogType keys). The concept you are using here is called mapped types. Mapped types basically generate a new type based on a union of keys (in this case the members of DialogType enum) and a set of mapping rules. The type we created above is basically equivalent to:

   let o: { [DialogType.Help]?: Dialog; [DialogType.Options]?: Dialog; }
   

See Playground.

enum Environment {
  Sandbox = "SANDBOX",
  Production = "PRODUCTION",
}
const keys = Object.keys(Environment);
console.log(keys) // ["Sandbox", "Production"]
console.log(Environment.Sandbox) // SANDBOX
console.log(keys.indexOf(Environment.Sandbox)) -1

You would need Object.values(Environment).

As described in the handbook:

Keep in mind that string enum members do not get a reverse mapping generated at all.

That means there is no simple reverse mapping in your case.

You can try some custom functions, like this:

function getEnumKeyByEnumValue(myEnum, enumValue) { let keys = Object.keys(myEnum).filter(x => myEnum[x] == enumValue); return keys.length > 0 ? keys[0] : null; }

You can use key in construct :

export const enum MutationKeys {
  registerUser = 'registration/REGISTER',
  registerUserCompleted = 'registration/REGISTER_COMPLETED'
}

type MutationDictionnary<P> = {
  [key in MutationKeys]: P
}

const mutations: MutationDictionnary<VuexMutation> = {
  'registration/REGISTER' {
    state.registration = {
      meta: {
        serverValidated: false
      },
      value: payload
    };
  },
  'registration/REGISTER_COMPLETED' {
    state.registration.meta.serverValidated = true;
  }
};