Deriving object type from array of objects

Given this type:

type ItemMetadata = {
    name: string;
    valueType: "string" | "number" | "boolean";
};

I want to construct an array of parameters

const MyMetaDatas = [
    {
        name: "The String",
        valueType: "string"
    },
    {
        name: "The Number",
        valueType: "number"
    }
] as const satisfies readonly ItemMetadata[];

And given this - readonly MyMetaDatas array, I would like to consturct an object which looks like this

const MyParameters = {
   "The String": "string",
   "The Number": "number"
}

And I want to "type" this object type as a generic with 1 parameter - typeof MyMetadatas - e.g. ParametersFor<T extends readonly ItemMetadata[]> = { ...TODO }

Attempt #1

/**
 * Attempt on generating { name: valueType } map object, from const array of ItemMetadata
 */
type ItemParameters<T extends readonly ItemMetadata[]> = {
    [K in T[number]["name"]]: T[number]["valueType"];
};
/**
 * Not nice because T[number]["valueType"] looks at all of the items in the array
type MyParams = {
  "The String": "string" | "number" | "boolean";
  "The Number": "string" | "number" | "boolean";
}
 */
type MyParams = ItemParameters<typeof MyMetaDatas>;

This does procudce the left side of the object correctly, but T[number] at the right side looks at the all of the items in the array, it produces OR types of all of the options...

Attempt #2
Tried multiple things, came up with this. This does not produce object, it produces a tuple of ojbects, where there is only one key - [name], and one value - [valueType].

type ParamsUsingSingle<T extends readonly ItemMetadata[]> = {
    [K in keyof T]: {
        [TName in T[K]["name"]]: T[K]["valueType"];
    }
};
type MyParamsUsingSingle = ParamsUsingSingle<typeof MyMetaDatas>;
/**
 * Close but now I would have to merge them into a signle object somehow.. Or to Flatten
 */
const x: MyParamsUsingSingle = [
    {
        "The String": "string"
    },
    {
        "The Number": "number",
    }
]

But now I need to merge them somehow...

Can anyone help me with this task?

Here are my numberous attempts in Typescript playground

You are in the right direction with your first attempt, however, you shouldn't just write T[number]['valueType'], since it will give a union of all possibilities. Instead, you should use key remapping:

type GetParameters<T extends readonly ItemMetadata[]> = {
  [K in T[number] as K["name"]]: K["valueType"];
};

Usage:

// type Params = {
//     "The String": "string";
//     "The Number": "number";
// }
type Params  = GetParameters<typeof MyMetaDatas>

playground