GeezerVison

type PromisifyNormal<T> = { [K in keyof T]: Promise<T[K]> }
type PromisifyNormalObject = PromisifyNormal<{ a: string, b: number, c: boolean }>
// {a: Promise<string>, b: Promise<number>, c: Promise<boolean>}
type PromisifyNormalTuple = PromisifyNormal<[string, number, boolean]>;
// [Promise<string>, Promise<number>, Promise<boolean>]

type PromisifySomeKeys<T, KT extends keyof T = keyof T> = { [K in KT]: Promise<T[K]> }
type PromisifySomeKeysObject = PromisifySomeKeys<{ a: string, b: number, c: boolean }>
// {a: Promise<string>, b: Promise<number>, c: Promise<boolean>}
type PromisifySomeKeysTuple = PromisifySomeKeys<[string, number, boolean]>;
/* 
type PromisifySomeKeysTuple = {
  [x: number]: Promise<string | number | boolean>;
  "0": Promise<string>;
  "1": Promise<number>;
  "2": Promise<boolean>;
  length: Promise<3>;
  ...
}
*/

type PromisifyIntersectionTuple = PromisifyNormal<[string, number, boolean] & { randomProp: 1234 }>;
/* 
type PromisifyIntersectionTuple = {
  [x: number]: Promise<string | number | boolean>;
  "0": Promise<string>;
  "1": Promise<number>;
  "2": Promise<boolean>;
  length: Promise<3>;
  ...
  randomProp: Promise<1234>;
}
*/

class Maybe<T>{}

type MaybeTuple = [Maybe<string>, Maybe<number>, Maybe<boolean>];

type MaybeType<T> = T extends Maybe<infer MaybeType> ? MaybeType : never;
type MaybeTypes<T> = {[P in keyof T]: MaybeType<T[P]>};

type extractedTypes = MaybeTypes<MaybeTuple>;

type extractedTypes = {
    [x: number]: string | number | boolean;
    "0": string;
    "1": number;
    "2": boolean;
    length: {};
    includes: {};
    toString: {};
    toLocaleString: {};
    push: {};
    pop: {};
    concat: {};
    join: {};
    reverse: {};
    shift: {};
    slice: {};
    sort: {};
    splice: {};
    unshift: {};
    indexOf: {};
    lastIndexOf: {};
    every: {};
    some: {};
    forEach: {};
    map: {};
    filter: {};
    reduce: {};
    reduceRight: {};
    entries: {};
    keys: {};
    values: {};
    find: {};
    findIndex: {};
    fill: {};
    copyWithin: {};
}

    pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
    pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
    pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
    pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
    pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;

type Promisify<T> = { [P in keyof T]: Promise<T[P]> };
// error:  A rest parameter must be of an array type.
async function  invokeWhenReady<T extends any[], R>(fn : (...a: T) => R, ...a: Promisify<T>) : Promise<R>{
    return null as any;
}

declare let ps: Promise<string>;
declare let px: Promise<number[]>;

const r = invokeWhenReady((s, x) => ({ s, x }), ps, px)  // Promise<{ s: string, x: number[] }>

type Boxified<T> = {
    [P in keyof T]: P extends keyof [] ? T[P] : Box<T[P]>
};

type Boxified<T> = {
    [P in keyof T]: Box<T[P]>
};

type Tuple = [1, 2];
type A<T> = { [K in keyof T]: string };

type WithAlias = A<Tuple> // [string, string]

type WithoutAlias = { [K in keyof Tuple]: string };
/*
  {
    [x: number]: string;
    0: string;
    1: string;
    length: string;
    ...
 */