TypeScript: improve UseCase#execute typing about almin HOT 11 CLOSED

type UseCases = AUseCase | BUseCase;
const context = new Context<UseCases>();
context.useCase(new AUseCase).execute(1,2,3);

type ParentUseCaseArgs = string;
class ParentUseCase extends UseCase {
    execute(value: ParentUseCaseArgs) {
        return this.context.useCase(new ChildUseCase()).execute(value);
    }
}
context.useCase(parentUseCase).execute<ParentUseCaseArgs>("arg").then(() => {
    const state = context.getState<StoreState>();
    console.log(state.A.a);
    console.log(state.B.b);
}).catch((error: Error) => {
    console.error(error);
});

class ParentUseCase extends UseCase {
    execute(value: string) {
        return this.context.useCase(new ChildUseCase()).execute(value);
    }
}
context.useCase(parentUseCase).execute("arg").then(() => {
    const state = context.getState<StoreState>();
    console.log(state.A.a);
    console.log(state.B.b);
}).catch((error: Error) => {
    console.error(error);
});

interface UseCaseBase {
    // define UseCase's methods and properties other than execute
    foo(): string;
}
interface UseCase0 extends UseCaseBase {
    execute(): any;
}
interface UseCase1<T1> extends UseCaseBase {
    execute(arg1: T1): any;
}
interface UseCase2<T1, T2> extends UseCaseBase {
    execute(arg1: T1, arg2: T2): any;
}
// ... create UseCaseX as many as you want

interface UseCaseConstructor {
    new (): UseCase0;
    new<T1> (): UseCase1<T1>;
    new<T1, T2> (): UseCase2<T1, T2>;
}

// Implementation of UseCase
abstract class _UseCase {
    abstract execute(...args: any[]): any;
    foo() {
        return '';
    }
}

// Cast UseCase
const UseCase = _UseCase as UseCaseConstructor;

class SomeUseCase extends UseCase {
    execute() {}
}

class AnotherUseCase extends UseCase<string> {
    execute(arg1: string) {}
}

class YetAnotherUseCase extends UseCase<string, number> {
    execute(arg1: string, arg2: number) {}
}

class Context {
    useCase(useCase: UseCase0): { execute(): Promise<void> };
    useCase<T1>(useCase: UseCase1<T1>): { execute(arg1: T1): Promise<void> };
    useCase<T1, T2>(useCase: UseCase2<T1, T2>): { execute(arg1: T1, arg2: T2): Promise<void> };
    useCase(useCase: { execute(...args: any[]): any }): { execute(...args: any[]): Promise<void> } {
        // todo implement
    }
}

context.useCase(new MyUseCase())
 .executor(useCase => useCase.execute("value"))
 .then(() => {
   console.log("test");
 });

// rough note
export interface UseCase<T>{
  execute(args: T);
}

type ResolveUseCaseArgType<T> =
  T extends UseCase<infer R> ? R : never;

class Context {
    useCase<T extends UseCase>(useCase: T): UseCaseExecutor<T>;
      type UseCaseArgs = ResolveUseCaseArgType<T>;
      return new UseCaseExecutor<UseCaseArgs>(useCase);
    }
}

import { UseCase, Context } from "almin";
class MyUseCaseA extends UseCase {
    execute(_a: string) {}
}
const context = new Context({
    store: createStore({ name: "test" })
});

// valid
context.useCase(new MyUseCaseA()).executor(useCase => useCase.execute("A")); 
// invalid
context.useCase(new MyUseCaseA()).executor(useCase => useCase.execute()); // no argument
context.useCase(new MyUseCaseA()).executor(useCase => useCase.execute(1)); // can not pass number
context.useCase(new MyUseCaseA()).executor(useCase => useCase.execute("A",  42)); // require 1 argument, but specify 2 arguments

import { UseCase, Context } from "almin";
class MyUseCaseA extends UseCase {
    execute(_a: string) {}
}
const context = new Context({
    store: createStore({ name: "test" })
});

// valid
context.useCase(new MyUseCaseA()).execute("A");
// invalid
context.useCase(new MyUseCaseA()).execute(); // no argument
context.useCase(new MyUseCaseA()).execute(1); // can not pass number
// **valid in almin 0.17**
// BUT, It should be error 
context.useCase(new MyUseCaseA()).execute("A". 42);