To achieve this, you can utilize the TS "in" keyword as shown below:

enum Choices {
  A = 'a',
  B = 'b',
  C = 'c',
}
interface ChoiceRequirements {
  isTrue: boolean;
  label: string;
}
type OptionCriteria = {
  [index in Choices]: ChoiceRequirements; // Take note of the "in" operator.
}

Learn more about the in keyword

An easy solution is to utilize the Record data structure

type RequirementOptions = Record<Options, OptionRequirement>

Alternatively, you can create it manually like this:

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

This syntax is only applicable to type, not interface.

The issue with your definition lies in specifying that the keys of your interface must be of type Options, which is an enum and not a string, number, or symbol.

The key in Options statement translates to "for those specific keys within the union type Options".

type alias offers more flexibility and power compared to interface.

If your type doesn't need to be used in classes, it's better to opt for type over interface.

Here's how I tackled the issue in my situation:

export type PossibleKeysType =
  | 'userAgreement'
  | 'privacy'
  | 'people';

interface ProviderProps {
  children: React.ReactNode;
  items: {
    //   ↙ there was an error with this colon
    [key: PossibleKeysType]: Array<SectionItemsType>;
  };
}

To resolve it, I made use of the in operator instead of using :

~~~

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

In a situation similar to mine, I encountered an issue with a different field property in the interface. My solution involved using an optional field property with an enum for keys:

export enum ACTION_INSTANCE_KEY {
  cat = 'cat',
  dog = 'dog',
  cow = 'cow',
  book = 'book'
}

type ActionInstances = {
  [key in ACTION_INSTANCE_KEY]?: number; // representing cat id/dog id/cow id/etc
};

export interface EventAnalyticsAction extends ActionInstances { 
  marker: EVENT_ANALYTIC_ACTION_TYPE;
}

In my scenario, I required the attributes to be able to be optional, so I devised a generic type for that purpose.

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

You can implement it like this:

type AttributeTypes = 'ATTR_A' | 'ATTR_B' | 'ATTR_C';

interface IData {
    title: string;
    value: number;
}

interface IInstance {
    attribute: string;
    optionals: OptionalAttributes<AttributeTypes, IData>;
}

Usage Example

const instance : IInstance = {
    attribute: 'some-attribute',
    optionals: {
        ATTR_A : {
            title: 'Title A',
            value: 100
        },
        ATTR_C : {
            title: 'Title C',
            value: 200
        }
    }
}

Instead of utilizing an interface, opt for a mapped object type

enum Choice {
  A = 'one',
  B = 'two',
  C = 'three'
}

type ChoiceKeys = keyof typeof Choice;

interface ChoiceCriteria {
  hasValue: boolean;
  description: string;
}

type ChoiceRequirements = {                 
  [key in ChoiceKeys]: ChoiceCriteria;   
}

modified

In summary: utilize Record<type1,type2> or a mapped object like:

type YourMapper = {
    [key in YourEnum]: SomeType
}

I encountered a similar problem, where the only allowed types for keys are string, number, symbol, or template literal type.

To address this, Typescript recommends using the mapped object type:

type Mapper = {
    [key: string]: string;
}

It's important to note that in a map object, we can only use strings, numbers, or symbols as keys. If we want to use specific strings (e.g., enum or union types), we should employ the in keyword within the index signature to refer to specific properties in the enum or union.

type EnumMapper = {
  [key in SomeEnum]: AnotherType;
};

For instance, suppose we aim to create an object with keys and values of specified types:

  const notificationMapper: TNotificationMapper = {
    pending: {
      status: EStatuses.PENDING,
      title: `${ENotificationTitels.SENDING}...`,
      message: 'loading message...',
    },
    success: {
      status: EStatuses.SUCCESS,
      title: ENotificationTitels.SUCCESS,
      message: 'success message...',
    },
    error: {
      status: EStatuses.ERROR,
      title: ENotificationTitels.ERROR,
      message: 'error message...'
    },
  };

To achieve this in Typescript, we need to define different types and then implement them using Record<> or a mapped object type:

export enum EStatuses {
  PENDING = 'pending',
  SUCCESS = 'success',
  ERROR = 'error',
}

interface INotificationStatus {
  status: string;
  title: string;
  message: string;
}

//option one, Record:
type TNotificationMapper = Record<EStatuses, INotificationStatus>

//option two, mapped object:
type TNotificationMapper = {
  [key in EStatuses]:INotificationStatus;
}

This approach applies to both enums and union types.

*PLEASE NOTE- using parentheses instead of square brackets (i.e., (...) instead of [...]) might not result in an error but signifies a function interface, such as:

interface Foo {
(arg:string):string;
}

which describes a function signature like:

const foo = (arg:string) => string;

Dealing with a similar challenge, I encountered difficulties in restricting the keys to be used in angular form validators.

export enum FormErrorEnum {
  unknown = 'unknown',
  customError = 'customError',
}

export type FormError = keyof typeof FormErrorEnum;

Here is how it can be implemented:

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

By utilizing this approach, you can control the number of keys being utilized.

To add extra properties and extend this concept further, you can follow this approach:

enum AdditionalOptions {
  FIRST = 'first',
  SECOND = "second",
  THIRD = 'third',
}

type RequirementOption = {
  isActive: boolean;
  description: string;
}

interface Expansion {
  title: string;
  choice: {[id in AdditionalOptions]: RequirementOption};
}

One example of utilizing this is to dynamically display or conceal certain elements.

enum DynamicElementEnum {
    HEADER = 'header', BODY = 'body', FOOTER = 'footer'
}

interface ElementTemplateBase {
    title: string;
    visibility?: {[id in DynamicElementEnum]?: boolean};
}

const sampleElement: ElementTemplateBase = {
    title: 'Demo',
    visibility: {
      header: true
    }
}

An innovative approach for aligning both key types and value types:

interface AdvancedSearchParameter {
        page: number;
        date: string;
        type: 'archived' | 'available',
        field: 'name' | 'type' | 'group'
}

const partialParams: Partial<AdvancedSearchParameter> = {page: 1}
//{page: '1'} error
//{page: 1 } true
//{ field: 'type', page: 1 } //true
//{ field: 'other' } //error

and a more flexible type:

{ [key in keyof AdvancedSearchParameter ]?: string | number }

//{ field: 'other' } true
//{'field1: 'type' } false