Sure. A function's type consists of the types of its argument and its return type. Here we specify that the callback parameter's type must be "function that accepts a number and returns type any":

class Foo {
    save(callback: (n: number) => any) : void {
        callback(42);
    }
}
var foo = new Foo();

var strCallback = (result: string) : void => {
    alert(result);
}
var numCallback = (result: number) : void => {
    alert(result.toString());
}

foo.save(strCallback); // not OK
foo.save(numCallback); // OK

If you want, you can define a type alias to encapsulate this:

type NumberCallback = (n: number) => any;

class Foo {
    // Equivalent
    save(callback: NumberCallback) : void {
        callback(42);
    }
}

This should do it:

const callMeMaybe = <T extends (...args: any[]) => any>(f: T, ...args: Parameters<T>): ReturnType<T> => {
  return f(...args);
}

const heyIJustMetYou = (a: number, b: string): string => b.repeat(a)

// errors as expected
const andThisIsCrazy = callMeMaybe(heyIJustMetYou, 3);

// Has type string
const butHeresMyNumberSo = callMeMaybe(heyIJustMetYou, 3, 'a');

Playground

Note that this doesn't work if f is itself generic. Also note that this isn't terribly useful. But you could make it return a thunk, and that would probably be more useful:

const thunkify = <T extends (...args: any[]) => any>(f: T, ...args: Parameters<T>): () => ReturnType<T> => {
  return () => f(...args);
}

...which returns a function that when called will call f with its arguments. This can be used to delay evaluation of f.

UPDATE

Better version, courtesy of jcalz in the comments:

const callMeMaybe = <A extends any[], R>(f: (...args: A) => R, ...args: A): R => {
  return f(...args);
}

Properly handles generic functions!

While you have found an approach that happens to work, it would typically be much simpler to define a class. In TypeScript, a class does two things. First, it defines a JavaScript class with a constructor and so on. Secondly, it defines an interface that we can use for typing. Then:

class Animal {
  legs(noOfLegs: number) {
    console.log(noOfLegs);
  }
}

const lion = new Animal();

const randomFunc = (lion: Animal)=>{
    lion.legs(4)
}

Alternatively, we could keep your existing function but just define an interface in addition. For example:

interface Animal {
  legs(noOfLegs: number): void;
}

const Animal = (): Animal => {
    const legs = (noOfLegs:number)=>{
        console.log(noOfLegs)
    }
    return {
        legs
    }
}

const lion = Animal();

const randomFunc = (lion: Animal)=>{
    lion.legs(4)
}

This works because values and types are in different namespaces, though in practice you might want to consider different names, for example an Animal interface but a makeAnimal function.