Declaring generic functions using callable interfaces in Typescript

Question

I'm trying to define typings for lodash/fp and its curried and overloaded functions. In order to keep it succinct and readable, I was attempting to define a few interfaces that would do all the currying combinations automatically, like this:

interface Curry1<A, Z> {
  (arg1: A): Z;
}

interface Curry2<A, B, Z> {
  (arg1: A): Curry1<B, Z>;
  (arg1: A, arg2: B): Z;
}

interface Curry3 { ... }

Using map as the test case, I want to define a function along these lines:

const map<T, U>: Curry2<(arg: T) => U, T[], U[]>;

But this is no good; you can't use generics in a variable declaration like this. I have also tried faking it using classes (which allow generics in this manner, but are not callable as functions) and namespaces (which don't seem to change anything at all, they just add more braces to the code).

Am I doomed to just redeclare a bunch of function overrides like this?

function map<T, U>(iteratee: (arg: T) => U): (data: T[]) => U[];
function map<T, U>(iteratee: (arg: T) => U, data: T[]): U[];

// This is equivalent to:

function map<T, U>(iteratee: (arg: T) => U): Curry1<T[], U[]>;
function map<T, U>(iteratee: (arg: T) => U, data: T[]): U[];

That last pair of overrides is just an inlined definition for Curry2, and it quickly gets obnoxious (especially when you get to Curry3 and Curry4), in addition to just being pointless grunt to write/generate.