You can currently do it much better this way (TypeScript 3.9):

// tslint:disable-next-line: no-any
type Constructor<T> = new (...args: any[]) => T;

export function ofType<TElements, TFilter extends TElements>(
    array: TElements[], 
    filterType: Constructor<TFilter>
): TFilter[] {
    return <TFilter[]>array.filter(e => e instanceof filterType);
}

Example usage:

class ClassA { }
class ClassB { }

const list: ClassA[] = [new ClassA(), new ClassB()];
const filteredList = ofType(list,  ClassB);

As @TobiasS. and @MuratKaragöz pointed out, the instanceof operator can not distinguish Foo and F at runtime, hence the generics are not passed down.

There are two paths to fixing this:

Using instanceof only

Unsafe at runtime

Instead of typing F with typeof Foo<number> as I did. We can create a new constructor type which return an instance of Foo<number>:

class Foo<T = number> {
  foo: T;

  constructor(foo: T) {
    this.foo = foo;
  }
}

const F: new (...args: ConstructorParameters<typeof Foo<number>>) => Foo<number> = Foo

let f: unknown = new F(0)

if (f instanceof F) {
  f.foo; // number
}

This is a very simple way of typing F, but it IS unsafe at runtime because it tricks Typescript into thinking Foo and F are not the same class, even thought (new Foo()) instanceof F returns true at runtime (see the safer method below).

Although, this trick can still be useful in few niche cases (I personally ended up using a combination of the safe and unsafe methods).

Safe at runtime

This is most likely the preferred solution, as it does not suffer from the same caveat as the unsafe solution above.

Put simply, we can create a new class F which extends Foo<number>:

class Foo<T = number> {
  foo: T;

  constructor(foo: T) {
    this.foo = foo;
  }
}

class F extends Foo<number> {
  constructor(...args: ConstructorParameters<typeof Foo<number>>) {
    super(...args)
  }
}

let f: unknown;

if (f instanceof F) {
  f.foo; // number
}

This IS safer because (new Foo()) instanceof F will return false at runtime, on the opposite of the unsafe solution.

Using type guards

See @TobiasS.'s and @MuratKaragöz's answers.

• https://stackoverflow.com/a/74626164/8990411
• https://stackoverflow.com/a/74626118/8990411

You can't do new T() because generics only exist in TypeScript, and there is no way to translate this to Javascript. However, you can do something similar with minor modifications.

abstract class BaseModel {
        constructor() {
            console.log('BaseModel constructor');
        }

        public abstract doSomething(x: string): string;
    }

    class AModel extends BaseModel {
        constructor() {
            console.log('constructor A');
            super();
        }

        public doSomething(x: string) {
            return `doSomething A: ${x}`;
        }
    }

    class BModel extends BaseModel {
        constructor() {
            console.log('constructor B');

            super();
        }

        public doSomething() {
            return 'doSomething B';
        }
    }

    class Operator<T extends BaseModel> {
        constructor(private readonly _createClass: {new (): T}) {}

        receiveX(): string {
            return 'x received';
        }

        createSomething(): T {
            const x = this.receiveX();
            // Code that's obviously not working:
            const model = new this._createClass();

            model.doSomething(x);
            
            return model;
        }
    }

    const aOperator = new Operator(AModel);
    const aModel = aOperator.createSomething();

    const bOperator = new Operator(BModel);
    const bModel = bOperator.createSomething();

Edits: trying to get code to format.

Edit2: here is a quick stackblitz

Unfortunately, you can't use instanceof because interfaces don't exist at runtime. You need to declare a type guard like so (see the Advanced Types Documentation):

function isINetworkObject(obj: any): obj is INetworkObject {
  return typeof obj.fixNetworkObject === 'function';
}

Then modify your if:

if (isINetworkObkect(ret)) {
  ret.fixNetworkObject();
}