Since you cannot mutate a class's type signature with a decorator, you have to use a function. Ultimately you have to tell Typescript what the function is going to do to the types, which is change them from required to optional. It provides a helper for this, Partial. So you can:

function Inject<T>(Component: React.Component<T>): React.Component<Partial<T>>

That re-writes your original types into:

interface FilterHeaderProps {
  applicationStore?: ApplicationStoreType;
  conversationsListStore?: ConversationsListStoreType
}

There are two elaborations on that concept:

• If the component has injected stores and other props
• If you want to enforce that the injected props are known stores

For the former, you can make the Inject function above take two type parameters, function Inject<T,U> and return a component where only one of them is made optional (React.Component<Partial<T> & U>). But then you have to explicitly tell the function which is which, verbosely:

interface FilterHeaderProps {
  applicationStore: ApplicationStoreType;
  conversationsListStore: ConversationsListStoreType;
  otherProp: string;
}

type Injected = Pick<FilterHeaderProps, 'applicationStore', 'conversationsListStore'>;
type Required = Pick<FilterHeaderProps, 'otherProp'>;

function Inject<T>(Component: React.Component<T>): React.Component<Partial<T>> {
  // ...
}

export default Inject<Injected, Required>(FilterHeaderComponent);

For the latter, you'd have to make an interface for your stores somewhere, then annotate the Inject component to take it, something like:

interface Stores {
    applicationStore: ApplicationStoreType;
  conversationsListStore: ConversationsListStoreType;
}


function Inject<T extends Stores>(Component: React.Component<T>, stores: Array<keyof Stores>): React.Component<Partial<T>> {
  // stores is e.g. ['applicationStore', 'conversationsListStore']
  return inject(...stores)(Component);
}

My syntax may not be precise but that is about what you have to do last I did this. I used this strategy in a large project and it was fine, but ultimately I did not like the verbosity and prefer just making the stores optional and using ! (e.g. this.props.applicationStore!.doTheThing()). In practice I never ran into any actual issues with the lack of type safety there. Yup if anyone knows of a less verbose way to achieve this in a typesafe way, i'd love to hear about it too.