@Experimental
@Consumer
@Named
public interface ModelTransformer extends SpiService {

    /**
     * Apply a transformation on the file model.
     *
     * This method will be called on each file model being loaded,
     * just before validation.
     *
     * @param model the input model
     * @return the transformed model, or the input model if no transformation is needed
     * @throws ModelTransformerException
     */
    @Nonnull

createAggregateTasks(sourceSet)
configureIde(TestType.CROSSVERSION)
configureTestFixturesForCrossVersionTests()

fun configureTestFixturesForCrossVersionTests() {
    // do not attempt to find projects when the plugin is applied just to generate accessors
    if (project.name != "gradle-kotlin-dsl-accessors" && project.name != "test" /* remove once wrapper is updated */) {
        dependencies {

But this way we can focus on how the **Dependency Injection** system works.

### Create a dependency, or "dependable" { #create-a-dependency-or-dependable }

Let's first focus on the dependency.

It is just a function that can take all the same parameters that a *path operation function* can take:

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8:9] *}

That's it.

**2 lines**.

            copySpec.rename(s -> destinationFile.getName());

            // TODO: Maybe this could be simplified by not using the copy infrastructure and just
            // calling the FilterReader ourselves.  We're just taking one file and turning it into another.

            // The order here is important! tokens are inserted by the transformer
            Map<String, Object> parameters = new HashMap<>();

    val call = client.newCall(request1)
    assertFailsWith<IllegalStateException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Timeouts can't be adjusted in a network interceptor")
    }
  }

  @Test
  fun networkInterceptorCannotChangeWriteTimeout() {
    addInterceptor(true) { chain: Interceptor.Chain ->
      chain
        .withWriteTimeout(

/// info

The `app.webhooks` object is actually just an `APIRouter`, the same type you would use when structuring your app with multiple files.

///

**FastAPI** provides the same `starlette.responses` as `fastapi.responses` just as a convenience for you, the developer. But most of the available responses come directly from Starlette.

///

## Returning a custom `Response` { #returning-a-custom-response }

# Security { #security }

There are many ways to handle security, authentication and authorization.

And it normally is a complex and "difficult" topic.

In many frameworks and systems just handling security and authentication takes a big amount of effort and code (in many cases it can be 50% or more of all the code written).

 * @since 20.0
 */
@Beta
public interface MutableNetwork<N, E> extends Network<N, E> {

  /**
   * Adds {@code node} if it is not already present.
   *
   * <p><b>Nodes must be unique</b>, just as {@code Map} keys must be. They must also be non-null.
   *
   * @return {@code true} if the network was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean addNode(N node);

  /**

{* ../../docs_src/handling_errors/tutorial006_py39.py hl[2:5,15,21] *}