The issue at hand arises from explicitly defining the type of instance as IHasIO. By doing this, you are instructing the compiler to disregard tracking its specific properties; instead, it will only recognize that instance belongs to type IHasIO, hence the inputs and outputs properties are inferred as type {[key: string]: string}, resulting in
keyof typeof instance["outputs"]
being simply
string. Consequently,
fn() will now accept any
string as input.
If you prefer stricter typing, allow the compiler to infer the type of instance by omitting the annotation. If ensuring that instance is assignable to
IHasIO</code without converting it to that type is crucial, TypeScript 4.9 introduces <a href="https://devblogs.microsoft.com/typescript/announcing-typescript-4-9-rc/#satisfies" rel="nofollow noreferrer">the <code>satisfies
operator:
const instance = {
inputs: {},
outputs: {
a: 'someValue',
b: 'someOtherVal'
}
} satisfies IHasIO;
Regardless of using satisfies or not, the type of instance is automatically inferred as:
/* const instance: {
inputs: {};
outputs: {
a: string;
b: string;
};
} */
Hence,
keyof typeof instance["outputs"]
becomes
"a" | "b". Consequently,
fn() functions as intended:
fn("c"); // error!
// ~~~
// Argument of type '"c"' cannot be assigned to
// parameter of type '"a" | "b"'.
fn("a"); // okay
fn("b"); // okay
The problem here is that by explicitly annotating the type of instance as IHasIO, you have essentially told the compiler that it should not try to keep track of its particular properties; instead it will only know that instance is of type IHasIO, and thus the inputs and outputs properties are of type {[key: string]: string}, meaning that
keyof typeof instance["outputs"]
is just
string. And therefore
fn() will accept any
string as input.
If you would like stronger typing, you should just let the compiler infer the type of instance, by leaving off the annotation. If you really care about verifying that instance is assignable to IHasIO without widening it to that type, you can use the satisfies operator which will be released in TypeScript 4.9:
const instance = {
inputs: {},
outputs: {
a: 'someValue',
b: 'someOtherVal'
}
} satisfies IHasIO;
But with or without satisfies, the type of instance is inferred to be
/* const instance: {
inputs: {};
outputs: {
a: string;
b: string;
};
} */
And therefore
keyof typeof instance["outputs"]
is
"a" | "b". And so
fn() now behaves as desired:
fn("c"); // error!
// ~~~
// Argument of type '"c"' is not assignable to
// parameter of type '"a" | "b"'.
fn("a"); // okay
fn("b"); // okay
Playground link to code