You can declare a `response_model`, using the default status code `200` (or a custom one if you need), and then declare additional information for that same response in `responses`, directly in the OpenAPI schema.

**FastAPI** will keep the additional information from `responses`, and combine it with the JSON Schema from your model.

dependencies {
    testImplementation localGroovy()
    testImplementation gradleTestKit()
}

// tag::declare-spock-dependency[]
dependencies {
    testImplementation('org.spockframework:spock-core:2.2-groovy-3.0') {
        exclude group: 'org.codehaus.groovy'
    }
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
// end::declare-spock-dependency[]

tasks.named('test', Test) {
    useJUnitPlatform()
}

Take for example a single-project build 'unpublished', that produces a java utility library but does not declare a value for the `group` attribute:

====
include::sample[dir="kotlin/anonymous-library",files="build.gradle.kts[]"]

 */
package org.codelibs.fess.app.logic;

import javax.annotation.Resource;

import org.codelibs.fess.mylasta.action.FessUserBean;
import org.dbflute.hook.AccessContext;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.core.time.TimeManager;
import org.lastaflute.db.dbflute.accesscontext.AccessContextResource;

public class AccessContextLogic {

// tag::all[]
import org.apache.commons.codec.binary.Base64

// tag::declare-classpath[]
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath group: 'commons-codec', name: 'commons-codec', version: '1.2'
    }
}
// end::declare-classpath[]

tasks.register('encode') {
    doLast {
        def byte[] encodedString = new Base64().encode('hello world\n'.getBytes())

        ex.message == "Cannot declare module replacement that replaces self: o:o->o:o"
    }

    def "detects cycles early"() {
        replacements.module("o:a").replacedBy("o:b")
        when: replacements.module("o:b").replacedBy("o:a")

        then:
        def ex = thrown(InvalidUserDataException)
        ex.message == "Cannot declare module replacement o:b->o:a because it introduces a cycle: o:b->o:a->o:b"

The plugin exposes two <<declaring_dependencies.adoc#sec:what-are-dependency-configurations,configurations>> that can be used to declare dependencies: `api` and `implementation`.
The `api` configuration should be used to declare dependencies which are exported by the library API, whereas the `implementation` configuration should be used to declare dependencies which are internal to the component.

.Declaring API and implementation dependencies
====

plugins {
    `java-library`
    `maven-publish`
}

group = "com.acme"
version = "1.0"

// tag::declare-outgoing-capabilities[]
configurations {
    apiElements {
        outgoing {
            capability("com.acme:my-library:1.0")
            capability("com.other:module:1.1")
        }
    }
    runtimeElements {
        outgoing {
            capability("com.acme:my-library:1.0")

...as `description` and `tax` are optional (with a default value of `None`), this JSON "`object`" would also be valid:

```JSON
{
    "name": "Foo",
    "price": 45.2
}
```

## Declare it as a parameter

To add it to your *path operation*, declare it the same way you declared path and query parameters:

=== "Python 3.10+"

    ```Python hl_lines="16"
    {!> ../../../docs_src/body/tutorial001_py310.py!}
    ```

abstract class JacksonBomAlignmentRule implements ComponentMetadataRule {
    void execute(ComponentMetadataContext ctx) {
        ctx.details.with {
            if (id.group.startsWith("com.fasterxml.jackson")) {
                // declare that Jackson modules belong to the platform defined by the Jackson BOM
                belongsTo("com.fasterxml.jackson:jackson-bom:${id.version}", false)
            }
        }
    }
}
// end::bom-alignment-rule[]