Typescript: 'टाइपऑफ फूबार' प्रकार का तर्क 'नया () => FooBarInterface' प्रकार के पैरामीटर के लिए असाइन करने योग्य नहीं है

हाय दोस्तों मैं टाइपस्क्रिप्ट ऐप्स के लिए एक आईओसी कंटेनर विकसित कर रहा हूं जिसे InversifyJS कहा जाता है। मैंने TypeBinding<TServiceType> नामक एक वर्ग लागू किया है जिसका उपयोग service type (इंटरफ़ेस) और implementation type (वर्ग) के बीच बाध्यकारी को परिभाषित करने के लिए किया जाता है। वर्ग कोड निम्नलिखित है:

// Defines allowed scope modes
enum TypeBindingScopeEnum {
  Transient,
  Singleton
}

class TypeBinding<TServiceType> {

    // The runtime identifier used because at runtime
    // we don't have interfaces
    public runtimeIdentifier : string;

    // The constructor of a class that must implement TServiceType
    public implementationType : { new(): TServiceType ;};

    // Cache used to allow singleton scope
    public cache : TServiceType;

    // The scope mode to be used
    public scope : TypeBindingScopeEnum;

    constructor(
      runtimeIdentifier : string,
      implementationType : { new(): TServiceType ;},
      scopeType? : TypeBindingScopeEnum) {

      this.runtimeIdentifier = runtimeIdentifier;
      this.implementationType = implementationType;
      this.cache = null;
      if(typeof scopeType === "undefined") {
        // Default scope is Transient
        this.scope = TypeBindingScopeEnum.Transient;
      }
      else {
        if(TypeBindingScopeEnum[scopeType]) {
            this.scope = scopeType;
        }
        else {
          var msg = `Invalid scope type ${scopeType}`;
          throw new Error(msg);
        }
      }
    }
}

मैंने TypeBinding<TServiceType> वर्ग के परीक्षण के लिए कुछ संस्थाओं को परिभाषित किया है:

interface FooInterface {
  logFoo() : void;
}

interface BarInterface {
  logBar() : void;
}

interface FooBarInterface {
  logFooBar() : void;
}

// Notice default constructor
class Foo implements FooInterface {
  public logFoo(){ 
    console.log("foo"); 
  }
}

// Notice default constructor
class Bar implements BarInterface {
  public logBar(){ 
    console.log("bar"); 
  }
}

// Notice dependencies on FooInterface and  BarInterface on constructor
class FooBar implements FooBarInterface {
  public foo : FooInterface;
  public bar : BarInterface;
  public logFooBar(){ 
    console.log("foobar"); 
  }
  constructor(FooInterface : FooInterface, BarInterface : BarInterface) {
    this.foo = FooInterface;
    this.bar = BarInterface;
  }
}

मैं TypeBinding<TServiceType> वर्ग का उपयोग कर सकता हूं जिसमें Foo और Bar कक्षाओं के साथ कोई समस्या नहीं है

var fooBinding = new TypeBinding<FooInterface>("FooInterface", Foo);
var barBinding = new TypeBinding<BarInterface>("BarInterface", Bar);

मेरी समस्या तब आती है जब मैं { new(): TServiceType ;} का उपयोग करने का प्रयास करता हूं और TServiceType लागू करने वाले वर्ग का निर्माता पैरामीटर रहित नहीं है।

'टाइपऑफ़ फूबार' प्रकार का तर्क 'नया () => फूबारइंटरफेस' प्रकार के पैरामीटर के लिए असाइन करने योग्य नहीं है।

var fooBarBinding = new TypeBinding<FooBarInterface>("FooBarInterface", FooBar);

इस मुद्दे के आसपास कैसे काम कर सकते हैं?

धन्यवाद :)