potential degradation of withMethods generic types inference about platform HOT 5 CLOSED

function EntityFilter<T extends object>(properties: (keyof T)[]) {
  const initial = Object.fromEntries(
    properties.map(prop => [prop, null])
  ) as { [K in keyof T]: T[K] | null }

  const entityFilterMethods = withMethods(store => ({
    updateFilter<K extends keyof T>(property: K, value: T[K]){
      patchState(store, (state) => ({
        ...state,
        [property]: value
      }));
    }
  }));

  return signalStore(withState(initial), entityFilterMethods);
}

export const createWithRequest = <RestEndpoint Record<string, string>>(
  restEndpoints: RestEndpoint,
) => ({
  withRequest: signalStoreFeatureFactory(restEndpoints),
});

export function signalStoreFeatureFactory<RestEndpoint extends Record<string, string>>(
  restEndpoints: RestEndpoint,
) {
  return () =>
    signalStoreFeature(
      withMethods(store => ({
        request: <Method extends keyof RestEndpoint & string>(method: Method) => {
          patchState(store, ...);
        },
      })),
    );
}

type RestEndpoints = {
  get: {
    'meetings': Meeting[] | null;
  };
};

const requestState: RestEndpoints = {
  get: {
    meetings: null,
  },
};

export const { withRequest } = createWithRequest(requestState);

export const SomeStore = signalStore(
  withRequest(),
  withMethods(store => ({
    foo() {
      store.request('getttt'); // it should fail but somehow it is `any` type
    },
  })),
);