Why are there different components types in OpenAPI?

Trying to wrap my head around OpenAPI difference between defining a reusable object in the components/schemas section or in the components/requestBodies if it's indeed an object that is the body of a request.

Is there any difference besides the separation of simple request payloads that are no real domain objects? Why do we have different sections for schemas, requestBodies, and responses?

Especially when looking at the generated client code I see no difference between a class that was defined in schemas or one defined in requestBodies.

A schema describes a specific data structure used by an API. Such as a certain object, its properties, their data types, and so on.

Some other component types use schemas as one of their building blocks.

A request body component defines whether the request body is required or optional, the supported media types for the request body (e.g. application/json, multipart/form-data, application/octet-stream) and the schema for each media type (these schemas can be the same or different).

Similarly, a response component defines not just the response schema, but also possible response media types and response headers.

If we rewrite the indicated parts as components, we end up with:

paths:
  /users:
    post:
      summary: Create a user
      requestBody:
        $ref: '#/components/requestBodies/createUser'
      responses:
        '201':
          $ref: '#/components/responses/userCreated'

components:
  schemas:
    User:
      type: object
      properties:
        id:
          type: string
          format: uuid
          readOnly: true
        name:
          type: string
          example: Helen
  
  requestBodies:
    createUser:
      required: true
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/User'
        application/x-www-form-urlencoded:
          schema:
            $ref: '#/components/schemas/User'
  
  responses:
    userCreated:
      description: >-
        The user was successfully created.
        The response contains the created user.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/User'

<br/>

While using components/schemas to give names to schemas is a common practice, using components/requestBodies and components/responses instead of inline definitions is more of a convenience thing. You would typically put the latter into components only if the same request body definition or response definition is duplicated in multiple places. For example, 401 and 403 responses usually have the same schema and description in all operations so you may want to $ref them to reduce the repetition, whereas 200/201 responses that need unique descriptions can be kept inline.

<br/>

> Especially when looking at the generated client code I see no difference between a class that was defined in schemas or one defined in requestBodies.

This might vary from one codegen to another. But it's probably because schemas are converted to classes, whereas request body and response attributes (such as media types) are expressed with annotations. So in the code generation context, it doesn't really matter if request bodies and responses are defined inline or in components.