Remove Index Signature

In this medium-level challenge, you'll implement RemoveIndexSignature<T> to exclude index signatures from object types, keeping only explicitly declared properties.

type Foo = {
[key: string]: any
foo(): void
}
 
type A = RemoveIndexSignature<Foo> // expected { foo(): void }

type Foo = {
  [key: string]: any
  foo(): void
}

type Bar = {
  [key: number]: any
  bar(): void
  0: string
}

const foobar = Symbol('foobar')
type FooBar = {
  [key: symbol]: any
  [foobar](): void
}

type Baz = {
  bar(): void
  baz: string
}

type cases = [
  Expect<Equal<RemoveIndexSignature<Foo>, { foo(): void }>>,
  Expect<Equal<RemoveIndexSignature<Bar>, { bar(): void; 0: string }>>,
  Expect<Equal<RemoveIndexSignature<FooBar>, { [foobar](): void }>>,
  Expect<Equal<RemoveIndexSignature<Baz>, { bar(): void; baz: string }>>,
]

Detailed Explanation

type RemoveIndexSignature<T> = {
  [K in keyof T as string extends K
    ? never
    : number extends K
      ? never
      : symbol extends K
        ? never
        : K]: T[K]
}

How it works:

• We use a mapped type that iterates over all keys K of T using keyof T.
• The as clause applies key remapping to filter out index signature keys.
• string extends K is true only when K is the broad string index signature (not for literal string keys like "foo"), so we map it to never to exclude it.
• Similarly, number extends K filters out [key: number]: any index signatures, while preserving specific numeric literal keys like 0.
• symbol extends K filters out [key: symbol]: any index signatures, while preserving specific unique symbol keys.
• Any key that passes all three checks is kept, and we preserve its original value type T[K].

This challenge helps you understand mapped type key remapping and how to distinguish between index signatures and explicitly declared properties in real-world scenarios.