Как люди обычно моделируют классы, которые реализуют интерфейс в объявлениях?

Question

Например, у меня есть что-то вроде этого:

declare module 'rxjs' { 
    declare interface CoreOperators<T> { 
    static merge<R>(...sources: Observable<R>[]): Observable<R>; 

    map<R>(f: (item: T) => R): Observable<R>; 
    scan<R>(f: (prev: R, next: T) => R): Observable<R>; 
    } 

    declare class Observable<T> implements CoreOperators<T> { 
    observableSpecificMethod: (f: Function): Observable<T> 
    } 
} 

Такое, что Observable<T> должны получить все подписи в интерфейсе и имеют свои собственные.

Answer 1

В потоке вы можете представлять интерфейс как тип и наследование как тип пересечения:

type CoreOperators<T> = { 
    map: <R>(f: (item: T) => R) => Observable<R>; 
    scan: <R>(f: (prev: R, next: T) => R) => Observable<R>; 
}; 

type Observable<T> = CoreOperators<T> & { 
    observableSpecificMethod: (f: Function) => Observable<T> 
}; 

Answer 2

я узнал только немного назад, что вы можете сделать class A и class B mixins A и что может быть ближе всего, что я должен работа с ...

Так что, может быть что-то вроде

declare module 'rxjs' { 
    declare class CoreOperators<T> { 
    static from(array: T[] | rxjs$ArrayLike<T>): Observable<T>; 
    static merge<R>(...sources: Observable<R>[]): Observable<R>; 

    do(f: (item: T) => any): Observable<T>; 
    map<R>(f: (item: T) => R): Observable<R>; 
    scan<R>(f: (prev: R, next: T) => R): Observable<R>; 
    skip(count: number): Observable<T>; 
    startWith(init: any): Observable<T>; 
    take(count: number): Observable<T>; 
    } 

    declare class Observable<T> mixins CoreOperators<T> { 
    subscribe(
     next: (item: T) => any, 
     error?: (error: any) => any, 
     complete?: (item: T) => any 
    ): Subscription; 
    } 
} 

Все еще копать, но это может быть единственным Avai прямо сейчас.