test('type-only args type test', () => {
    const accept = <T>(x: T) => x;

    class TestElement extends ReactiveElement {
      foo: string = 'foo';
      bar: number = 123;

      task = new Task(this, {
        task: ([foo, bar]) => {
          accept<string>(foo); // Argument of type 'string | number' is not assignable to parameter of type 'string'.
          accept<number>(bar); // Argument of type 'string | number' is not assignable to parameter of type 'number'.
        },
        args: () => [this.foo, this.bar],
      });
    }
    TestElement;
  });

      task1 = new Task(
        this,
        ([string, number]) => {
          expectType<string>(string);
          expectType<number>(number);
        },
        () => [this.string, this.number]
      );

// Defining constructors with generic type parameters as per https://github.com/microsoft/TypeScript/issues/10860
export type ITask = {
  new <
    const T extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
    const R = unknown,
  >(
    host: ReactiveControllerHost,
    task: TaskFunction<T, R>,
    args?: ArgsFunction<T>
  ): Task<T, R>;
  new <
    const T extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
    const R = unknown,
  >(
    host: ReactiveControllerHost,
    task: TaskConfig<T, R>
  ): Task<T, R>;
// ... other members omitted
};
///...
    const T = Task as unknown as ITask;

      task = new T(this, {
        task: ([string, number]) => {
          expectType<string>(string); // Argument of type 'string | number' is not assignable to parameter of type 'string'.
          expectType<number>(number); // Argument of type 'string | number' is not assignable to parameter of type 'number'.
        },
        args: () => [this.string, this.number],
      });

// Defining a wrapper function
export function useTask<const T extends ReadonlyArray<unknown>, const R>(
  host: ReactiveControllerHost,
  task: TaskFunction<T, R>,
  args?: ArgsFunction<T>
): Task<T, R>;
export function useTask<const T extends ReadonlyArray<unknown>, const R>(
  host: ReactiveControllerHost,
  config: TaskConfig<T, R>
): Task<T, R>;
export function useTask<const T extends ReadonlyArray<unknown>, const R>(
  host: ReactiveControllerHost,
  task: TaskFunction<T, R> | TaskConfig<T, R>,
  args?: ArgsFunction<T>
): Task<T, R> {
  return new Task(host, task as TaskFunction<T, R>, args);
}

// ...

      task3 = useTask(this, {
        task: ([string, number]) => {
          expectType<string>(string); // Argument of type 'string | number' is not assignable to parameter of type 'string'.
          expectType<number>(number); // Argument of type 'string | number' is not assignable to parameter of type 'number'.
        },
        args: () => [this.string, this.number],
      });

  constructor(host: ReactiveControllerHost, task: TaskConfig<T, R>) {

// ...

      task = new Task(this, {
        task: ([string, number]) => {
          expectType<string>(string); // all good!
          expectType<number>(number);
        },
        args: () => [this.string, this.number],
      });