<plugin>
        <groupId>org.codehaus.modello</groupId>
        <artifactId>modello-maven-plugin</artifactId>
        <configuration>
          <version>2.0.0</version>
          <basedir>${project.basedir}/../api/maven-api-settings</basedir>
          <velocityBasedir>${project.basedir}/../src/mdo</velocityBasedir>
          <models>
            <model>src/main/mdo/settings.mdo</model>
          </models>
          <params>

    def "does not configure build when action does not query any models"() {
        setupBuild()

        when:
        def model = withConnection {
            def executer = action(new NoOpAction())
            collectOutputs(executer)
            executer.run()
        }

        then:
        model == "result"

        and:
        assertHasConfigureSuccessfulLogging()

 * of project dependencies. This optimizes module loading during runtime, as we will only load external
 * modules that are not loaded transitively by other project modules.
 *
 * We perform this filtering, since if we simply include all external dependencies, regardless of whether
 * they are already loaded transitively, there is a measurable performance impact during module-loading.
 */

    @TargetGradleVersion(">=4.4")
    def "can get models with parameters"() {
        when:
        def model = withConnection { connection ->
            connection.action(new ParameterAction()).run()
        }

        then:
        model.isBuiltWithParameter()
        model.getParameterValue() == "myParameter"
    }

    @TargetGradleVersion(">=4.4")
    def "can get model without parameters for old gradle versions"() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.models

import org.gradle.internal.extensions.stdlib.uncheckedCast
import org.gradle.tooling.provider.model.UnknownModelException


sealed class IntermediateModel {
    abstract fun <T> result(): T?

    class NoModel(val message: String) : IntermediateModel() {

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
    id("gradlebuild.publish-public-libraries")
}

description = "Declarative DSL Tooling Models for IDEs"

dependencies {
    compileOnly(project(":tooling-api"))

    compileOnly(libs.kotlinStdlib) {
        because(
            "used by the compiler, but there should be no binary dependency on the stdlib; " +

/**
 * Caches auxiliary data used during model building like already processed raw/effective models. The data in the cache
 * is meant for exclusive consumption by the model builder and is opaque to the cache implementation. The cache key is
 * formed by a combination of group id, artifact id, version and tag. The first three components generally refer to the

// This is a generated file. Do not edit directly.

module k8s.io/apimachinery

go 1.22.0

require (
	github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5
	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
	github.com/fxamacker/cbor/v2 v2.7.0-beta
	github.com/gogo/protobuf v1.3.2
	github.com/golang/protobuf v1.5.4
	github.com/google/gnostic-models v0.6.8
	github.com/google/go-cmp v0.6.0
	github.com/google/gofuzz v1.2.0

Using this same trick, you could use a Pydantic model to define the JSON Schema that is then included in the custom OpenAPI schema section for the *path operation*.

And you could do this even if the data type in the request is not JSON.

Eoin Fennessy <******@****.***> 1715615475 +0100