Working with Dynamic Keys in a Typescript Class using Generics

I'm running into an issue with the type system in TS when using extends keyof.
In this case I have a TreeContent object, however I want the tree to allow dynamic keys of where the data it is held in the tree object that the constructor uses.

I'm calling the class like so

const tree = new Tree<
            TestTree,
            "children",
            "data",
            TestTreeData,
            "label"
        >(treeTestData, "children", "data", "label");

The children key is to access the children data inside of the TestTree and the same with data and label, however, label will be used to find the label inside the TestTreeData. My aim here is to create a flexible class that can construct an n-ary tree from tree data that could use different aliases for children and the data it stores.

export class Tree<
    TreeContent,
    ChildKey extends keyof TreeContent,
    DataKey extends keyof TreeContent,
    Data,
    LabelKey extends keyof Data
>

{
    id: string;
    children: NodeModel<Data>[];
    childrenKey: ChildKey;
    dataKey: DataKey;
    labelKey: LabelKey;
    data: Data;

constructor(
        treeContent: TreeContent,
        _childrenKey: ChildKey,
        _dataKey: DataKey,
        _labelKey: LabelKey,
        _id = uuidv4()
    ) {
        this.dataKey = _dataKey;
        this.childrenKey = _childrenKey;
        this.labelKey = _labelKey;
        this.children = [];
        this.id = _id;

       if (
           !(_childrenKey in treeContent) ||
           !Array.isArray(treeContent[this.childrenKey])
          ) {
              throw Error(`Could not find data in ${String(this.childrenKey)}`);
          }

          const children = treeContent[this.childrenKey];

}

I omitted some of the other code in the constructor because I don't feel like it's relevant to the problem.

The issue is that children is const children: TreeContent[ChildKey] is not a type of an array even though I explicitly check if it's an array. I'm aware I can cast it however, I'm trying my best to avoid casting in my case. If that's the option I'm left with then that's fine but I can't figure out what I'm doing wrong.

I may be coming at this the completely wrong way, which I suspect.

What I want is that I can inform TS that I expect the value of const children: TreeContent[ChildKey] to become const children: TreeContent[]
Then I could replicate the logic with the DataKey but TreeContent[DataKey] should equal a Generic data object.

EDIT:
Here is a TS Playground with an error showing that I can't use the push function.

You already have that the ChildKey and DataKey generic type parameters are constrained to be keys of the TreeContent type parameter.

You don't have any further constraints on the type of value at the DataKey key, so there's no apparent reason for you to have a Data type parameter all all; instead you can just use the indexed access type TreeContent[DataKey] to refer to the type you were calling Data.

On the other hand, you need to constrain the type of value at the ChildKey key so that it is an array of TreeContent. You can do this by constraining TreeContent to Record<ChildKey, TreeContent[]>, using the Record<K, V> utility type. (This doesn't mean that TreeContent can't have more properties than just ChildKey; object types are open in TS and are allowed to have more properties than mentioned. It just means that ChildKey has to be one of the keys, and its property must be assignable to TreeContent[].

Once you make those changes, things should start behaving as desired:

class Tree<
    TreeContent extends Record<ChildKey, TreeContent[]>,
    ChildKey extends keyof TreeContent,
    DataKey extends keyof TreeContent,
    LabelKey extends keyof TreeContent[DataKey]
>{
    children: TreeContent[];
    childrenKey: ChildKey;
    dataKey: DataKey;
    labelKey: LabelKey;
    data: TreeContent[DataKey];

    constructor(treeContent: TreeContent, _childrenKey: ChildKey,
        _dataKey: DataKey, _labelKey: LabelKey ) {
        this.dataKey = _dataKey;
        this.childrenKey = _childrenKey;
        this.labelKey = _labelKey;
        this.children = [];
    
        const children = treeContent[this.childrenKey];
        // const children: TreeContent[ChildKey]    
        children.push(); // okay
    
        this.data = treeContent[_dataKey]; // okay
    }
}

function createTree() {
    const tree = new Tree(testTreeData, "children", "data", "label");
    // const tree: Tree<TestTree, "children", "data", "label">
}

Looks good. Note that you don't need to manually specify the type arguments when calling the Tree constructor. The compiler infers them correctly for you automatically.

Playground link to code