La solución más simple es usar Record

 type OptionRequirements = Record<Options, OptionRequirement>

También puede implementarlo usted mismo como:

 type OptionRequirements = { [key in Options]: OptionRequirement; }

Esta construcción sólo está disponible para type , pero no como interface .

El problema en su definición es decir que la clave de su interfaz debe ser del tipo Options , donde Options es una enumeración, no una cadena, un número o un símbolo.

La key in Options significa "para esas claves específicas que están en el tipo de unión Opciones".

type alias es más flexible y potente que interface .

Si su tipo no necesita ser usado en clase, elija type sobre interface .

Puede usar el operador TS "en" y hacer esto:

 enum Options { ONE = 'one', TWO = 'two', THREE = 'three', } interface OptionRequirement { someBool: boolean; someString: string; } type OptionRequirements = { [key in Options]: OptionRequirement; // Note that "key in". }

Tuve un problema similar, pero mi caso fue con otra propiedad de campo en la interfaz, por lo que mi solución es un ejemplo con una propiedad de campo opcional con una enumeración para las claves:

 export enum ACTION_INSTANCE_KEY { cat = 'cat', dog = 'dog', cow = 'cow', book = 'book' } type ActionInstances = { [key in ACTION_INSTANCE_KEY]?: number; // cat id/dog id/cow id/ etc // <== optional }; export interface EventAnalyticsAction extends ActionInstances { // <== need to be extended marker: EVENT_ANALYTIC_ACTION_TYPE; // <== if you wanna add another field to interface }

En lugar de usar una interfaz, use un tipo de objeto mapeado

 enum Option { ONE = 'one', TWO = 'two', THREE = 'three' } type OptionKeys = keyof typeof Option; interface OptionRequirement { someBool: boolean; someString: string; } type OptionRequirements = { // note type, not interface [key in OptionKeys]: OptionRequirement; // key in }

Tuve un problema similar. Estaba tratando de usar solo claves específicas al crear validadores de forma angular.

 export enum FormErrorEnum { unknown = 'unknown', customError = 'customError', } export type FormError = keyof typeof FormErrorEnum;

Y el uso:

 static customFunction(param: number, param2: string): ValidatorFn { return (control: AbstractControl): { [key: FormErrorEnum]?: any } => { return { customError: {param, param2} }; }; }

Esto permitirá utilizar 1 - X número de claves.

En mi caso, necesitaba que las propiedades fueran opcionales, así que creé este tipo genérico.

 type PartialRecord<K extends string | number | symbol, T> = { [P in K]?: T; };

Entonces úsalo como tal:

 type MyTypes = 'TYPE_A' | 'TYPE_B' | 'TYPE_C'; interface IContent { name: string; age: number; } interface IExample { type: string; partials: PartialRecord<MyTypes, IContent>; }

Ejemplo

 const example : IExample = { type: 'some-type', partials: { TYPE_A : { name: 'name', age: 30 }, TYPE_C : { name: 'another name', age: 50 } } }

En mi caso:

 export type PossibleKeysType = | 'userAgreement' | 'privacy' | 'people'; interface ProviderProps { children: React.ReactNode; items: { // ↙ this colon was issue [key: PossibleKeysType]: Array<SectionItemsType>; }; }

Lo arreglé usando el operador in lugar de usar :

 ~~~ interface ProviderProps { children: React.ReactNode; items: { // ↙ use "in" operator [key in PossibleKeysType]: Array<SectionItemsType>; }; }