You could make the function generic in T, the element type of the output array (so if the array produces a [X, Y, Z][] then T is [X, Y, Z]) and then give the function a rest parameter whose of a mapped tuple/array type over T:

declare function zipComp<T extends any[]>(
    ...args: { [I in keyof T]: T[I][] }
): T[]

In the mapped type { [I in keyof T]: T[I][] }, for each numeric-like index I in the T array, the element type T[I] at that index is mapped to an array of those elements T[I][]. So if T is [X, Y, Z], then the mapped type is [X[], Y[], Z[]].

Note that because the mapped type in question is homomorphic (as described in What does "homomorphic mapped type" mean? ) the compiler is able to infer T from the value passed in for args. (If this weren't true, then inference might fail and we'd need to rewrite the call signature.)

Also note that rest argument types tend to be inferred as tuple types by the compiler instead of just unordered array types, which is what we want.

All of this means that, if args is of type [X[], Y[], Z[]] then the output will be of type [X, Y, Z][].

Or at least it should be; let's try it out:

const nb = zipComp([1, 2], [false, true]);
// const nb: [number, boolean][];

const sno = zipComp(["a", "b", "c"], [1, 2, 3], [{}, {}, {}]);
// const sno: [string, number, {}][];

const hmm = zipComp([""], [1], [true], [new Date()], [null], 
   [undefined], [Symbol()], [() => 2]);
// const hmm: [string, number, boolean, Date, null, 
//   undefined, symbol, () => 2][]

Looks good! The compiler happily produces the output type from the input type even with relatively long inputs.

Playground link to code

Edit Since the original answer typescript has added support for tuples in rest parameters in 3.0. With this we can achieve the desired result without all the overloads:

type UnionToIntersection<U> = 
    (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never

function mixIt<T extends any[]>(...args: T): UnionToIntersection<T[number]>{ 
    let mixin: any =  {};

    args.forEach( obj => {
        for(let key in obj) {
            if( ! mixin.hasOwnProperty(key) ) {
                mixin[key] = obj[key];
            }
        }
    });

    return mixin;
}

Original answer

There is no way to currently have a variable number of type parameters, there is a proposal on this.

The only way to currently do this is to add as many signatures to the functions as needed, so in your case this would be:

function mixIt<A, B>   (a: A, b: B): A & B;
function mixIt<A, B, C>(a: A, b: B, c: C): A & B & C;
function mixIt<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
function mixIt<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): A & B & C & D & E;
function mixIt<A, B, C, D, E, F>(a: A, b: B, c: C, d: D, e: E, f: F): A & B & C & D & E &F ;
// Private signature
function mixIt(...args: any[]): any{ // no need for this to be generic
    let mixin: any =  {};

    args.forEach( obj => {
        for(let key in obj) {
            if( ! mixin.hasOwnProperty(key) ) {
                mixin[key] = obj[key];
            }
        }
    });

    return mixin;
}

Use function overloading:

function fn<T>(args: T[]): Something<T>
function fn<T>(...args: T[]): Something<T>
function fn<T>(...args: ([T[]]) | T[]): Something<T> {
  // ...
}

To get a union of all arguments you can use U[number]:

function bind<U extends any[]>(...args: U): U[number] {
    return args[Math.round(Math.random()*(args.length - 1))]; // dummy implementation
}
let r = bind(1,"2", true) // number | string | boolean
console.log(r)

You can also get the type at a certain position, but since we don't know if the position will exist we need to use a conditional type;

type At<T extends any[], I extends number> = T extends Record<I, infer U> ? U : never;
function bind<U extends any[]>(...args: U): At<U, 0> {
    return args[Math.round(Math.random()*(args.length - 1))]; // dummy implementation
}
let r = bind(1,"2", true) // number

Thanks to the help of @Etheryte i got onto the right search track.

I found the sollution i wanted which is:

function SampleFunction<T extends any[]>(
    cb: (...args: T) => void,
    ...args: T
): void {}

let stringVariable = 'lorem';
let numberVariable = 8;

SampleFunction(
    (a, b) => {}, 
    stringVariable, 
    numberVariable
);

This implicitly passes the right argument types from the function into the callback

The compiler infers tuple types for generic rest parameters properly, when type parameter T has an array type constraint <T extends Boxed<any>[]> instead of an item constraint:

type Boxed<T> = { inner: T }

const box = <T>(inner: T): Boxed<T> => ({ inner });

// here 'extends Boxed<any>[]' instead of 'extends Boxed<any>'
function test<T extends Boxed<any>[]>(...args: T): T extends Boxed<infer I>[] ? I : never {
    return args[0].inner;
}

test(box(0), box('str')); // string | number 🎉
test(...[box(0), box('str')]); // string | number 🎉

Playground

If you write it T extends Boxed<any>>(...args: T[]), TS apparently is eager to infer the whole array type by the type of first item, as all rest parameter items are supposed to have the same type.

declare function foo<T extends string | number>(...args: T[]): void
// foo<"bar">(...args: "bar"[]): void;
foo("bar", 1) // nono, '1' is not assignable to parameter of type '"bar"'

This notation resolves the generic rest parameters correctly.

declare function foo2<T extends (string | number)[]>(...args: T): void
// foo2<["bar", 1]>(args_0: "bar", args_1: 1): void
foo2("bar", 1)