Here is a fully annotated example as function expression:

const sum: ({ 
  arg1, 
  arg2,
  arg3 
}: {
  arg1: number;
  arg2: number;
  arg3: number;
}) => number = ({ arg1, arg2, arg3 }) => arg1 + arg2 + arg3;

Here is another and better alternative for arrow functions. Only arguments are annotated and compiler can infer return type correctly. Function has less clutter and works just as before.

const sum = ({ 
  arg1,
  arg2,
  arg3
}: {
  arg1: number;
  arg2: number;
  arg3: number;
}) => arg1 + arg2 + arg3;

If you are going to annotate your function in a seperate file:

interface Args {
  arg1: number;
  arg2: number;
  arg3: number;
}

type Sum = (input: Args) => number;

const sum: Sum = ({ arg1, arg2, arg3 }) => arg1 + arg2 + arg3;

You can use any as argument type if argument types are not known. Return type will be inferred as any:

const sum = ({ 
  arg1,
  arg2,
  arg3
}: any) => arg1 + arg2 + arg3;

So this one is equivalent to previous example:

const sum: ({ arg1, arg2, arg3 }: any) => any

This may not make that much sense for arrow functions but you can set types for known arguments and use key-value pairs for annotating addititional argumens:

const sum = ({ 
  arg1,
  arg2,
  arg3
}: {
  arg1: number;
  arg2: number;
  arg3: number;
  [key: string]: number;
}) => arg1 + arg2 + arg3;

You can also use generics:

interface Args {
  arg1: number;
  arg2: number;
  arg3: number;
}

const sum = <T extends Args>({ 
  arg1,
  arg2,
  arg3
}: T) => arg1 + arg2 + arg3;

Here is same examples, sum as function statement.

function sum({
  arg1,
  arg2,
  arg3
}: {
  arg1: number;
  arg2: number;
  arg3: number;
}): number {
  return arg1 + arg2 + arg3;
}

If you have complicated implementation detail in your function's body, function statement can be better choice for its ergonomics. Plus generics looks less clumsy on function statements.

Objects and functions are fundamentally the same thing, but typings help us disambiguate between their functionality.

Consider this:

const foo1: { (): string } = () => "";

The variable foo has a type of object, but that object is callable ... it's a function, and it can indeed be called, but you can't go setting a property called bar on it.

foo1(); // This works
foo1.bar = 5; // This, not so much.

Also consider this:

const foo2: { bar?: number; } = {};

The variable foo has a property called bar on it. That property can be set, but the object can't be called, as it's not typed as callable.

foo2.bar = 5; // This works
foo2(); // This, not so much.

So, lets have a look at your original typing:

sortQuery = {}

sortQuery is an object, but that's all that we know about it. It doesn't have any properties, it's not callable, it's just an object.

We've already seen that a function is an object, so you can assign a function to it just fine. But, you won't be able to call it, as it's not defined as callable.

const sortQuery: {} = () => ""; // This works.
sortQuery(); // This, not so much.
sortQuery.bar = 5; // Nor this.

If you have full control of the source code, then one way to solve this is to move from multiple parameters, to a single parameter with named properties:

const foo = (params: { collection: string, query: object, sortQuery: {}, cb?: Function }) => { };

foo({ collection: "", query: {}, sortQuery: {} }); // Fine
foo({ collection: "", query: {}, sortQuery: {}, cb: () => { } }); // Fine
foo({ collection: "", query: {}, cb: () => { } }); // Not Fine

This removes any ambiguity by requiring names, rather than relying on position in the function call.

You can pick exact type of arguments with tsargs package from npm

Eg:

import { ArgsN } from 'tsargs';

function foo(a: boolean, b: number, c: string) {}
const argsABC: ArgsN<typeof foo> = [ true, 123, 'Hello' ];

In your case:

import { ArgsN } from 'tsargs';

function parse<T extends (...args: any[]) => any>(args: IArguments): ArgsN<T> {
    // return parsed arguments
}

// ...

const args = parse<typeof foo>(arguments);
// args -> [ boolean, number, string ];

I think what you are looking for can be achieved by the using overloads of the function. This will allow:

1. To have a function with a single parameter.
2. Inform the different types to the type system.
3. Change the function behavior depending on the type you received. (This violate the OOP principle of Single responsibility, but let's go back to your question...)

So your function overloads would look something like this:

function doThingFunc(arg: { query: string, somthingElse?: string }): void;
function doThingFunc(arg: string): void
function doThingFunc(arg: any): void {
  if (typeof arg === 'object') {
    console.log(arg.query);
  }
  if (typeof arg === 'string') {
    console.log(arg);
  }
}
const doThing = doThingFunc;


doThing('some query');
doThing({ query: 'some query', somthingElse: 'something else' });

Of course, with this implementation you lose the this binding when used inside an object that arrow functions provide out of the box. More details here: https://www.typescriptlang.org/docs/handbook/functions.html