TypeScript: How to restrict index signature parameter type's keys?

You approach of using a mapped type is the correct one.

An object type in Typescript does not guarantee the absence of extra properties on the object at runtime. Any subtype (in effect a type with more properties) can be assigned to a base type. So this code would be valid:

type TestKey = 'a' | 'b' | 'c';
function printTestValue(key: TestKey, value: string) {
    console.log(key, value);
}

const someValue = { a: "A", b: "B", c: "C", d: 1 }
const testValues: { [key in TestKey]: string } = someValue; // ok typeof somevelu is a subtype 

for (const key in testValues) {
    if (Object.hasOwn(testValues, key)) {
        // At runtime key will be "d" and testValues[key] will be a number
        printTestValue(key, testValues[key]);
    }
}

Playground Link

So this is why when using for..in or Object.keys we get string not keyof testValues.

You can use a type assertion if you want to avoid this compiler error: printTestValue(key as TestKey, testValues[key as TestKey]); (Playground Link)

If you want to be safe from base type aliasing you can check exhaustively for the keys, make sure you only deal with expected keys and ignore (or error) on unexpected keys:

const testKeys = ["a", "b", "c"] as const
type TestKey = typeof testKeys[number]

function isTestKey(key: string): key is TestKey {
    return testKeys.includes(key as TestKey)
}
function printTestValue(key: TestKey, value: string) {
    console.log(key, value);
}


const someValue = { a: "A", b: "B", c: "C", d: 1 }
const testValues: { [key in TestKey]: string } = someValue;
for (const key in testValues) {
    if (Object.hasOwn(testValues, key) && isTestKey(key)) {
        printTestValue(key, testValues[key]);
    } else {
        // throw new Error("Unexpected key")
    }
}

Playground Link

First of all I would create an array of all possible keys that we can also access on runtime:

const testKeys = ['a', 'b', 'c'] as const
type TestKeys = typeof testKeys[number]

We can also create a type guard to check if a string is actually of type TestKeys:

const keyIsTestKey = (key: string): key is TestKeys => {
  return testKeys.includes(key as TestKeys)
}

When we create an object like testValues you may use the following type:

const testValues: Partial<Record<TestKeys, string>> = {
  a: 'A',
  b: 'B'
}

This specifies that only TestKeys values can be used as keys but you don't have to specify all keys.

A bigger problem is the for ... in loop. In TypeScript the type of the key in for ... in loops is always string. But we can use the type guard here to make sure that key is actually of type TestKeys.

for (const key in testValues){
  if (keyIsTestKey(key)){
    /* ... */
  }
}

Now for the last part: Since key is now of type 'a' | 'b' | 'c' but testValues must not have all keys testValues[key] may be undefined...

I would use the Non-null assertion operator ! here since we are sure at this point that this can't be undefined.

for (const key in testValues){
  if (keyIsTestKey(key)){
    if (Object.hasOwn(testValues, key))
      printTestValue(key, testValues[key]!)
  }
}

Playground