How to create an instance from a generic type in TypeScript?

You seem to be confusing the TypeScript type annotations with runtime JavaScript concrete implementations.

In TypeScript you cannot do a new T(), because T is just a type annotation and has no concrete implementation.

Your type field undefined so naturally private emptyModel: T = new this.type(); will fail.

I think you were onto the right solution.

Create the Proxy class not as a singleton, but as a class.

Then create a service that exposes a factory method for returning an instance.

export class ProxyFactoryService {

    constructor(private httpClient: HttpClient) { }

    proxyFactory<T>(newable: new() => T) {
      const instance = new newable(); 
      return new ProxyService<T>(this.httpClient, instance);
    }
}

Then your ProxyService can look something like:

 export class ProxyService<T> {
   private localstorageService: LocalstorageDataService<T>;
   private remoteDataService: RemoteDataService<T>;

   constructor(private httpClient: HttpClient, private instance: T) {
     this.localstorageService = new LocalstorageDataService(this.instance, this.httpClient);
     this.remoteDataService = new RemoteDataService(this.instance, this.httpClient)
   }

   getOne(id: number): Observable<T> {
     if (this.instance.use_localstorage) { // we probably want to make sure T extends {use_localStorage: boolean}
       return of(this.localstorageService.findById(id));
     } else {
       return this.remoteDataService.getOne(id).pipe(map((result: T) => result));
    }
  }
  // other proxy functions are here...
}

To use this

constructor(private proxyService: ProxyService) {}

ngOnInit() {
  const proxy = this.proxyService.proxyFactory(SomeClass);
  proxy.getOne(...);
}

Always ask yourself the question: How would this work with annotations removed?

When TypeScript compiles all type annotations are removed -- these are just design time static type annotations.

Another way to think of it is this simplification -- we will remove the generics out and use concrete types. But in essence this boils down what you were trying to do:

const s: new () => String;
const i = new s();

So s is a constructor that when called returns a type String. This will not work because s is undefined. We know what the type it is supposed to be, but in fact it is undefined. This is all very contrived -- but I hope this helps.

If we look at the compiler output for the above, it should be more clear why this wont work.

const s;
const i = new s();

TypeScript luckily will error before we ever actually get a chance to run this code. If your IDE is setup right you should get lots of warnings and errors at design time.

I understand this can be frustrating and confusing, especially coming from languages like C# and Java where the CIL/CLR is statically type aware. In TypeScript there is no runtime, it is just compiled to JavaScript.

Static typing and type annotations are not available at runtime.