const array = [6, 'foo'] as [number, string];
array.push(99);
type NewArrayType = typeof array;
// We expect: [number, string, number]
// We get: [number, string]

/** A step simply converts the given data to something new */
type Step<TInput, TOutput> = (input: TInput) => Promise<TOutput>;

/** A process is simply an array of steps that can be executed all in order */
class Process<TData> {
  public constructor(private initialData: TData) { }

  /** Keep a list of all steps we have built up */
  private steps: Step<any, any>[] = [];

  /** Append a step to the process. Note that the return type is used for the workaround only. */
  public push<TOutput>(step: Step<TData, TOutput>): this is Process<TOutput> {
    this.steps.push(step);
    return true;
  }

  /** Same as the above, but we'll return ourselves as a different type */
  public push2<TOutput>(step: Step<TData, TOutput>): Process<TOutput> {
    this.steps.push(step);
    return this as unknown as Process<TOutput>; // TS doesn't like this change in type since TOutput has no relation to TInput
  }

  /** Execute all steps one by one, feeding the result of the previous one to the next */
  public async run(): Promise<TData> {
    let data = this.initialData;
    for (const step of this.steps) {
      data = await step(data);
    }
    return data;
  }
}

// This step requires no data, and will create a property id
// Also, having TOutput be determined implicitely here from the lambda would be amazing
const setIdStep: Step<{}, { id: string }> = input => Promise.resolve({ id: '093c3d72-6b8b-413c-ad5e-8787226402c3' });
// This step requires an id and will create some data
const fetchDataStep: Step<{ id: string }, { id: string, data: { foo: number } }> = input => Promise.resolve({ ...input, data: { foo: 99 } });

// How we want to use this class without TS errors
async function desiredSyntax() {
  const p = new Process({});
  p.push(setIdStep);
  p.push(fetchDataStep); //<- Error: Property 'id' is missing in type '{}' but required in type '{ id: string; }'.
  const result = await p.run();
  console.log(result.data.foo); //<- Error: Property 'data' does not exist on type 'Promise<{}>'.
}

// How to fool TS in thinking it is doing it correctly
async function workaround() {
  const p = new Process({});
  if (p.push(setIdStep)) {
    if (p.push(fetchDataStep)) {
      const result = await p.run(); // { id: string, data: any }
      console.log(result.data.foo)
    }
  }
}

// Another workaround, but this gets even more error prone that the previous one
async function workaround2() {
  const p = new Process({});
  const p2 = p.push2(setIdStep); // Just assign a new variable which will have the correct type since we forced it to
  const p3 = p2.push2(fetchDataStep);
  const result = await p3.run();
  console.log(result.data.foo);
}