React + Typescript: Type of React component with no state/no props

As answered for this question, you can use the React.FC<{}> class

const MyStatelessComponent : React.FC<{}> = props =>
    <div>{props.children}</div>

Or if your markup gets bigger:

const MyStatelessComponent : React.FC<{}> = props => {

    {/*  Some code here */}
    return <div>{props.children}</div>

}

According to this guideline and my exp, I would say :

1. class Foo extends React.Component<null, null> {} when you know you will not recieve props nor state
2. class Foo extends React.Component<any, any> {} when you know you will recieve props and state but you really don't care what they look like
3. class Foo extends React.Component<{}, {}> {} never saw, seems strange
4. class Foo extends React.Component<undefined, undefined> {} same as null, it's up to you. I see more often null than undefined
5. class Foo extends React.Component<void, void> {} bad idea, since seems to be reserved for functions return (when you do not expect one)

Other opinions are welcomed

You can use VoidFunctionComponent for stateless ans propless components (without state ana props):

const MyComponent: React.VoidFunctionComponent = () => {
  ...
}

I always create a props Interface for each component, even if it's blank. It keeps things consistant and allows me to easily add props later if needed.

Interface FooProps { }

class foo extends React.Component<FooProps, any> {
}

Functional components with no props

Use React.FC without any generic parameter like this:

const ProplessComponent: React.FC = () => {
  // Component implementation
};

React.FC is essentially the same as React.FC<Record<string, never>>, but shorter and more readable.

Don't use React.FC<{}> because {} in Typescript actually means "any non-nullish value".

Functional components with no STATE and no props

With the introduction of React hooks, functional components can manage internal state. Thus, the distinction between stateful and stateless components has become less significant. It's recommended to use React.FC for both types of components.

It's worth noting that React.SFC and React.StatelessComponent are deprecated. It's preferable to use React.FC instead even for stateless components.

Stateful(class based components) & Stateless components there's a lot of conceptions on the internet about when use one or another, I've grasped these concepts using this list (before have practical experience):

Stateless

1. Are concerned with how things look.
2. May contain both presentational and container components** inside, and usually have some DOM markup and styles of their own.
3. Often allow containment via this.props.children.
4. Have no dependencies on the rest of the app, such as Flux actions or stores.
5. Don’t specify how the data is loaded or mutated.
6. Receive data and callbacks exclusively via props.
7. Are written as functional components

Examples: Menu, UserInfo, List, SideBar.

Stateful

1. Are concerned with how things work.
2. May contain both presentational and container components** inside but usually don’t have any DOM markup of their own except for some wrapping divs, and never have any styles.
3. Provide the data and behavior to presentational or other container components.
4. Call Redux actions and provide these as callbacks to the presentational components.

Examples: UserPage, FollowersSidebar, ArticlesContainer.