Use existing class with openapi-generator-maven-plugin without skipping validation

I am using plugin openapi-generator-maven-plugin in version 6.3.0 and openapi 3.0.3 (yaml spec).

I want to use an existing model class instead of creating it by generator. I almost used the existing class successfully in generated api, but I had to skip the validation of spec by setting <skipValidateSpec>true</skipValidateSpec>.

Is there a way of keeping the spec validation active?

Here is my current config which works with skipped validation:

			<plugin>
				<groupId>org.openapitools</groupId>
				<artifactId>openapi-generator-maven-plugin</artifactId>
				<version>6.3.0</version>
				<executions>
					<execution>
						<goals>
							<goal>generate</goal>
						</goals>
						<configuration>
							<inputSpec>
								${project.basedir}/src/main/resources/openapi.yaml
							</inputSpec>
							<generatorName>spring</generatorName>
							<apiPackage>com.example.openapigenerator.api</apiPackage>
							<skipValidateSpec>true</skipValidateSpec>
							<languageSpecificPrimitives>ArticleEntity</languageSpecificPrimitives>
							<importMappings>
								ArticleEntity=com.example.openapigenerator.model.Article
							</importMappings>
							<modelPackage>com.example.openapigenerator.model</modelPackage>
							<configOptions>
								<interfaceOnly>true</interfaceOnly>
								<useSpringBoot3>true</useSpringBoot3>
								<legacyDiscriminatorBehavior>false</legacyDiscriminatorBehavior>
							</configOptions>
						</configuration>
					</execution>
				</executions>
			</plugin>

paths:
  /article:
    post:
      tags:
        - article
      summary: Add a new article to the store
      description: Add a new article to the store
      operationId: addArticle
      requestBody:
        description: Create a new article in the store
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ArticleEntity'
        required: true
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ArticleEntity'

components:
  schemas:
    ArticleEntity:
      $ref: '#/components/schemas/Article'

Using an external model is simple. Let's pretend we have a class called MyExternalClass.java. We first need to make sure the generator knows where this class lives. We do this with out importMappings. However, we also need to tell our generator what object to replace. This means we have to have an object to replace. Let's create a dummy object for our schema called MyUnusedClass. Our resulting schema would look like this:

paths:
  /class:
    post:
      tags:
        - article
      summary: Add a new article to the store
      description: Get an Object
      operationId: getObject
      requestBody:
        description: get my object
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/MyInternalClass'
        required: true
      responses:
        '200':
          description: Successful operation
components:
  schemas:
    MyInternalClass:
      type: object
      properties:
        date:
          type: string
        name:
          type: string
        id:
          type: string
          format: uuid

Now we are half way there. Your swagger documentation knows about the dummy schema that we have created. However, your generator doesn't know about the external version of this schema. As I explained previously, We can easily set that up with our typeMappings.

<plugin>
    <groupId>org.openapitools</groupId>
    <artifactId>openapi-generator-maven-plugin</artifactId>
    <version>6.3.0</version>
    <executions>
        <execution>
            <goals>
                <goal>generate</goal>
            </goals>
            <configuration>
                <inputSpec>
                    ${project.basedir}/src/main/resources/openapi.yaml
                </inputSpec>
                <generatorName>spring</generatorName>
                <apiPackage>com.example.openapigenerator.api</apiPackage>
                <skipValidateSpec>true</skipValidateSpec>
                <languageSpecificPrimitives>ArticleEntity</languageSpecificPrimitives>
                <importMappings>
                    MyExternalClass=my.package.containing.MyExternalClass
                </importMappings>
                <typeMappings>
                    MyInternalClas=MyExternalClass
                </typeMappings>
                <modelPackage>com.example.openapigenerator.model</modelPackage>
                <configOptions>
                    <interfaceOnly>true</interfaceOnly>
                    <useSpringBoot3>true</useSpringBoot3>
                    <legacyDiscriminatorBehavior>false</legacyDiscriminatorBehavior>
                </configOptions>
            </configuration>
        </execution>
    </executions>
</plugin>

Note that in the above maven, I have not only told the generator to import the class, but I have told the generator to replace every occurrance of MyInternalClass with MyExternalClass.

BONUS TIP

Even though the generator knows to replace the occurances of MyInternalClass with MyExternalClass, it will still generate java class. This takes up space and can be confusing to other developers on your team. To prevent this, add it to your .openapi-generator-ignore file. Now it will be like the schema never existed in the first place.

Taking @tbatch 's answer further, the typeMappings brougth me to the following solution:

paths:
  /article:
    post:
      tags:
        - article
      summary: Add a new article to the store
      description: Add a new article to the store
      operationId: addArticle
      requestBody:
        description: Create a new article in the store
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Article'
        required: true
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Article'

components:
  schemas:
    Article:
      type: object
      format: article

<plugin>
	<groupId>org.openapitools</groupId>
	<artifactId>openapi-generator-maven-plugin</artifactId>
	<version>6.3.0</version>
	<executions>
		<execution>
			<goals>
				<goal>generate</goal>
			</goals>
			<configuration>
				<inputSpec>
					${project.basedir}/src/main/resources/openapi.yaml
				</inputSpec>
				<generatorName>spring</generatorName>
				<apiPackage>com.example.openapigenerator.api</apiPackage>
				<skipValidateSpec>false</skipValidateSpec> <!-- My intended goal, to keep spec validation active -->
				<importMappings>
					Article=com.example.openapigenerator.model.Article
				</importMappings>
				<typeMappings>object+article=Article</typeMappings> <!-- THIS DID THE TRICK FOR ME -->
				<modelPackage>com.example.openapigenerator.model</modelPackage>
				<configOptions>
					<interfaceOnly>true</interfaceOnly>
					<useSpringBoot3>true</useSpringBoot3>
					<legacyDiscriminatorBehavior>false</legacyDiscriminatorBehavior>
				</configOptions>
			</configuration>
		</execution>
	</executions>
</plugin>