Typescript type which validates abstract class and instance of class extending same abstract class

I want to write a function in typescript with custom requirements:

• Function can be named anything let's assume it to be speak
• Function must accept two arguments as a and b respectively.
• Argument a must be an abstract class for example speak(AbstractService) (See example for clarification)
• Argument b must be a class instance which extends argument a abstract class . For example RuntimeUserService. (See example for clarification)

Here are some examples of expected behavior written in code. We will not be using any code inside speak function, rather just typescripts intellisense and errors are wanted.

Example:

// Basic Environment Setup
abstract class SampleUserService{}
class RuntimeUserService implements SampleUserService{}
class DoNotWork{}


// Example 1: Should work, because RuntimeUserService implements/extends SampleUserService provided as 1st argument.
speak(SampleUserService, new RuntimeUserService);

// Example 2: Should not work, as instance of RuntimeUserService is not created
speak(SampleUserService, RuntimeUserService);

// Example 3: Should not work as DoNotWork does not implement/extends SampleUserService provided as 1st argument.
speak(SampleUserService, new DoNotWork());

// Example 4: Do not work as it is just a class declaration similar to example 2
speak(SampleUserService, DoNotWork); // should not work

Here is what I have tried, but with no success.

type AbstractServiceConstructor<T> = abstract new (...args: any[]) => T;

function speak<T extends AbstractServiceConstructor<T>, U extends InstanceType<any>>(a: T, b: U) {
  // Function body
}

abstract class SampleUserService {}
class RuntimeUserService extends SampleUserService {}
class DoNotWork {}


// Gets errors for 1st argument
speak(SampleUserService, new RuntimeUserService()); // Works
speak(SampleUserService, RuntimeUserService); // Error: Argument of type 'typeof RuntimeUserService' is not assignable to parameter of type 'SampleUserService'
speak(SampleUserService, new DoNotWork()); // Error: Argument of type 'DoNotWork' is not assignable to parameter of type 'SampleUserService'
speak(SampleUserService, DoNotWork); // Error: Argument of type 'typeof DoNotWork' is not assignable to parameter of type 'SampleUserService'

One big problem with your example is that your classes are all empty, which is known to confuse people. TypeScript's type system is largely structural and not nominal. Two object types with the same shape (same member properties) are considered to be the same type, even if they have separate declarations. The types declared in class Foo {} and abstract class Bar {} and interface Baz {} and type Qux = {} are all identical to {} and thus to each other. If you want TS to accept a RuntimeUserService but reject a DoNotWork, then you'll need to make sure that they have different structures. The easy way to fix that is to add some structure:

abstract class SampleUserService { a = 1; }
class RuntimeUserService extends SampleUserService { b = 2; }
class DoNotWork { c = 3; }

Now those three types are different; a SampleUserService has a numeric a property; a RuntimeUserService has that plus a numeric b property, and a DoNotWork has a numeric c property but no known a property.

Once you do that you can fix speak() to look like this:

function speak<T>(a: AbstractServiceConstructor<T>, b: T) { }

You only need one generic type parameter T corresponding to the instance type. Then a is of type AbstractServiceConstructor<T> (which will structurally match even non-abstract constructors; see the release notes for abstract construct signatures, but that should be okay unless you have some unusual reason for rejecting that), and b is of type T. Let's test it out:

speak(SampleUserService, new RuntimeUserService); // okay
speak(SampleUserService, RuntimeUserService); // error
speak(SampleUserService, new DoNotWork()); // error
speak(SampleUserService, DoNotWork); // error

It only accepts cases where the value passed as the second argument is (structurally identical to) an instance of the (possibly abstract) class constructor passed as the first argument.

Playground link to code