Random hacks you can do with TypeScript.

random-hacks.ts

type Status = "passed" | "failed" | "error" | "unknown";

interface Things {
  a: string;
  b: number;
  c: {
    d: {
      e: string;
    };
    f: Array<{ g: number }>;
  };
}

// example
interface PromisedThings {
  a: Promise<string>;
  b: Promise<number>;
  c: {
    d: {
      e: Promise<string>;
    };
  };
}

type PromiseObject<O> = {
  [K in keyof O]: O[K] extends object ? PromiseObject<O[K]> : Promise<O[K]>
};

const foo: PromiseObject<Things> = {} as any;
const a = foo.a;
const e = foo.c.d.e;
const g = foo.c.f[0].g;

type UnpromiseObject<O> = {
  [K in keyof O]: O[K] extends Promise<infer V>
    ? V
    : O[K] extends PromiseObject<infer V>
    ? V
    : O[K]
};

const bar: UnpromiseObject<PromiseObject<Things>> = {} as any;
bar.c.d.e;

///

interface State {
  value: number;
}
const state: State = {} as any;

interface Actions {
  inc: (n: number) => number;
  dec: (n: number) => number;
  reset: () => [number, string];
  somethingElse: string;
}

const _actions = {
  inc(n: number) {
    return state.value + n;
  }
};

type _Actions = TransformActions<typeof _actions>;

interface ActualActions {
  inc: (n: number) => (state: State) => Promise<number>;
  dec: (n: number) => (state: State) => Promise<number>;
  reset: () => (state: State) => Promise<[number, string]>;
}

type TransformActions<A> = {
  [K in keyof A]: (
    ...args: FunctionArgs<A[K]>
  ) => (state: State) => Promise<FunctionResult<A[K]>>
};

type FunctionArgs<F> = F extends (...args: infer Args) => any ? Args : never;
type FunctionResult<F> = F extends (...args: any[]) => infer Result
  ? Result
  : never;

const actions: TransformActions<Actions> = {} as any;
const value: Promise<number> = actions.inc(3)(state);
actions.somethingElse(); // error