How to fix Type parameter for mapped type must be 'in' expression in TypeScript

// WRONG - missing 'in'
type Partial<T> = {
  [K]?: T[K];  // Error: Type parameter for mapped type must be 'in' expression
};

// CORRECT - add 'in'
type Partial<T> = {
  [K in keyof T]?: T[K];  // ✓ Correct syntax
};

// Another example:
// WRONG
type ReadonlyProps<T> = {
  [P]: T[P];  // Error
};

// CORRECT
type ReadonlyProps<T> = {
  readonly [P in keyof T]: T[P];  // ✓
};

// WRONG - typo
type Mapped<T> = {
  [K inn keyof T]: T[K];  // 'inn' instead of 'in'
};

// WRONG - uppercase
type Mapped<T> = {
  [K IN keyof T]: T[K];  // 'IN' instead of 'in'
};

// WRONG - wrong keyword
type Mapped<T> = {
  [K of keyof T]: T[K];  // 'of' instead of 'in'
};

// CORRECT
type Mapped<T> = {
  [K in keyof T]: T[K];  // ✓
};

// WRONG - missing space
type Mapped<T> = {[K inkeyof T]: T[K]};  // 'inkeyof' should be 'in keyof'

// CORRECT
type Mapped<T> = {[K in keyof T]: T[K]};  // ✓ Space after 'in'

// WRONG - using a type that isn't valid for iteration
type Colors = 'red' | 'green' | 'blue';
type ColorValues = {
  [C in Colors]: string;  // ✓ This is actually correct!
};

// WRONG - trying to iterate over non-union type
type BadExample = {
  [K in string]: any;  // Error: string is too broad for mapped types
};

// CORRECT - use keyof to get keys from an object type
interface User {
  id: number;
  name: string;
  email: string;
}

type OptionalUser = {
  [K in keyof User]?: User[K];  // ✓ Makes all properties optional
};

// CORRECT - iterate over literal union
type Status = 'pending' | 'success' | 'error';
type StatusMap = {
  [S in Status]: boolean;  // ✓ Creates {pending: boolean, success: boolean, error: boolean}
};

// INDEX SIGNATURE (not a mapped type)
interface StringDictionary {
  [key: string]: string;  // ✓ No 'in', just [key: type]: valueType
}

// MAPPED TYPE (requires 'in')
type ReadonlyDictionary<T> = {
  readonly [K in keyof T]: T[K];  // ✓ Uses 'in' keyword
};

// WRONG - mixing syntax
type ConfusedType = {
  [key: keyof T]: T[key];  // Error: Should be [K in keyof T]: T[K]
};

// CORRECT - choose one pattern
// Option 1: Index signature (all string keys)
type StringIndex = {
  [key: string]: number;
};

// Option 2: Mapped type (specific keys)
type SpecificKeys = {
  [K in 'x' | 'y' | 'z']: number;
};

// WRONG - error in nested mapped type
type DeepMapped<T> = {
  [K in keyof T]: {
    [P]: T[K][P];  // Error here! Missing 'in' in nested mapped type
  };
};

// CORRECT - fix nested mapped type
type DeepMapped<T> = {
  [K in keyof T]: {
    [P in keyof T[K]]: T[K][P];  // ✓
  };
};

// Another example with conditional types:
// WRONG
type ConditionalMapped<T> = T extends object ? {
  [K]: T[K]  // Error: missing 'in'
} : never;

// CORRECT
type ConditionalMapped<T> = T extends object ? {
  [K in keyof T]: T[K]  // ✓
} : never;

// Check template literal types (TypeScript 4.1+):
// WRONG
type TemplateMapped = {
  [K in `prefix_${string}`]: K;  // ✓ This is actually correct syntax!
  // Template literal types work with 'in'
};

// Working examples to compare:

// Basic mapped type
type Partial<T> = { [P in keyof T]?: T[P] };

// Mapped type with modifier
type Readonly<T> = { readonly [P in keyof T]: T[P] };

// Mapped type from union
type EventHandlers = { [E in 'click' | 'hover']: () => void };

// Mapped type with conditional value
type Nullable<T> = { [P in keyof T]: T[P] | null };

// Mapped type renaming keys (as clause)
type Getters<T> = {
  [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
};