Property 'positions' does not exist on type

I have this interface:

interface ScrollPositionRestore {
  event: Event;
  positions: { [K: number]: number };
  trigger: 'imperative' | 'popstate';
  idToRestore: number;
}

And this RxJS scan operator:

filter(
  (event) =>
    event instanceof NavigationStart || event instanceof NavigationEnd,
),
scan<Event, ScrollPositionRestore>((acc, event) => ({
  event,
  positions: {
    ...acc.positions,
    ...(event instanceof NavigationStart
      ? {
          [event.id]: this.contentArea.nativeElement.scrollTop,
        }
      : {}),
  },
  trigger:
    event instanceof NavigationStart
      ? event.navigationTrigger
      : acc.trigger,
  idToRestore:
    (event instanceof NavigationStart &&
      event.restoredState &&
      event.restoredState.navigationId + 1) ||
    acc.idToRestore,
})),

But I'm getting several TS errors:

positionsis declared on the ScrollPositionRestore interface, so why is TS not using that?

Using the scan operator can be tricky. The type of the accumulator parameter will either the accumlator type unioned with the source type, or the accumlator type unioned with the type of the seed (the second parameter to scan).

Since you're not providing a seed, the type of acc is properly being inferred as Event_2 | ScrollPositionRestore. The syntax error appears, since positions is not a property on Event_2 and therefore cannot be on the unioned type.

To get around this you should rewrite the call to scan and provide a seed that's the same type as the accumlator type.

filter(
  (event): event is NavigationStart | NavigationEnd => // I like my filters typed.
    event instanceof NavigationStart || event instanceof NavigationEnd,
),
scan<Event, ScrollPositionRestore, ScrollPositionRestore>((acc, event) => ({
  /* do the same assignment as before */
}), { positions: {} }) // <-- seed

It's not clear it works this way from the documentation, however if you look at the source, you'll see that for the function overloads that provide a seed, the return type is either just the accumulator type when no seed type is provided or the union of the accumulator and seed type when the seed type is provided.