Can you explain how to use multiple generic parameters with arrays in TypeScript

typescript
class Tuple<T, U> {
  private items: [T, U];

  constructor(first: T, second: U) {
    this.items = [first, second];
  }

  getFirst(): T {
    return this.items[0];
  }

  getSecond(): U {
    return this.items[1];
  }
}

// Using the generic Tuple class
const stringNumberTuple = new Tuple<string, number>("Hello", 42);
console.log(stringNumberTuple.getFirst()); // Output: "Hello"
console.log(stringNumberTuple.getSecond()); // Output: 42

const booleanStringTuple = new Tuple<boolean, string>(true, "World");
console.log(booleanStringTuple.getFirst()); // Output: true
console.log(booleanStringTuple.getSecond()); // Output: "World"

// Using arrays with multiple generic parameters
function zipArrays<T, U>(arr1: T[], arr2: U[]): [T, U][] {
  return arr1.map((item, index) => [item, arr2[index]]);
}

const numbers = [1, 2, 3];
const strings = ["a", "b", "c"];
const zipped = zipArrays(numbers, strings);
console.log(zipped); // Output: [[1, "a"], [2, "b"], [3, "c"]]

In this example, we have a `Tuple` class that takes two generic type parameters, `T` and `U`. The class has a private property `items` that is an array with two elements, the first of type `T` and the second of type `U`.

The `Tuple` class also has two methods, `getFirst` and `getSecond`, that return the first and second elements of the tuple, respectively, preserving their original types.

We then demonstrate how to use the `Tuple` class with different type combinations, creating instances of `stringNumberTuple` and `booleanStringTuple`.

Next, we introduce a `zipArrays` function that takes two arrays, one of type `T[]` and one of type `U[]`, and returns an array of tuples `[T, U][]`. This function uses the `map` method to iterate over the first array and create a new array of tuples, where each tuple contains the corresponding elements from the two input arrays.

We then demonstrate the usage of the `zipArrays` function by passing in two arrays, one of `number` and one of `string`, and logging the resulting array of tuples.

The key benefits of using multiple generic parameters with arrays in TypeScript are:

1. Type safety: The generic type parameters ensure that the arrays and tuples are type-safe, preventing type-related errors.
2. Flexibility: The `Tuple` class and the `zipArrays` function can work with a variety of data types, making them more reusable.
3. Expressiveness: The use of generic parameters makes the code more expressive and easier to understand, as the type information is explicit.