Why keyof operator retreives non enumerable inherited? properties from object literal type?

Please, consider this TypeScript code:

'use strict';

type Value = 1 | 2 ;
type Owner = 'ownerA' | 'ownerB';
type ItemType = 'itemTypeA' | 'itemTypeB';
type Item = {
  type: ItemType;
  owner: Owner;
  value: Value;
};

type AnotherType = {
  [k in keyof Item]: null | {
    [m in keyof Item[k]]: number;
  };
};

const v: AnotherType = {
  type: { itemTypeA: 0, itemTypeB: 1,},
  owner: { ownerA: 0, ownerB: 1,},
  value: null,
};

console.log(v);

The tsc throws an error in this case:

> error TS2322: Type '{ itemTypeA: number; itemTypeB: number; }' is not
> assignable to type '{ [x: number]: number; toString: number; charAt:
> number; charCodeAt: number; concat: number; indexOf: number;
> lastIndexOf: number; localeCompare: …

Apparently the [m in keyof Item[k]]: number; iteration for some reason includes the non-enumerable, even non-present properties (not sure if an object type can inherit from Object.prototype's type) like: charCodeAt, charAt etc.

Up to my knowledge this contradicts the documentation on the 'keyof' type operator, which is described as:

> The keyof operator takes an object type and produces a string or
> numeric literal union of its keys. The following type P is the same
> type as type P = "x" | "y": type Point = { x: number; y: number };
> type P = keyof Point;

i.e. there are no 'charAt' et al. values in the produced union, only 'x' and 'y'.

May be it has something to do with the in operator, but again, in JS it traverses only thru enumerable properties of an object (not sure if that's true in TypeScript when it's used as a type operator).

Could someone please explain, what's happening here?

You should change your type to something like

type AnotherType = {
    [K in keyof Item]: null | {
        [M in Item[K]]: number; // <-- no keyof
    };
};

where you don't use the keyof operator inside the nested mapped type.

The problem with M in keyof Item[K] is that Item[K] is an indexed access type into the Item interface, and thus one of ItemType, Owner, or Value, which are already the unions of key-like literal types you want. And since Item[K] is already keylike, writing keyof Item[K] is evaluating keys-of-keys. Presumably you don't care about the keys of strings like "ownerA" (e.g., "toUpperCase", "length", etc) or the keys of numbers like 1 (e.g., "toFixed"). Instead you should just iterate over Item[K] directly. After all, we want {[M in Owner]: number}, nut {[M in keyof Owner]: number}.

After we make that change, AnotherType is equivalent to

type AnotherType = {
    type: {
        itemTypeA: number;
        itemTypeB: number;
    } | null;
    owner: {
        ownerA: number;
        ownerB: number;
    } | null;
    value: {
        1: number;
        2: number;
    } | null;
}

as desired.

Playground link to code