// tag::inner-link-task-properties[]
def archivesDirPath = layout.buildDirectory.dir('archives')
// end::inner-link-task-properties[]

tasks.register('packageClasses', Zip) {
    archiveAppendix = "classes"
    destinationDirectory = archivesDirPath

    from compileJava
}
// end::link-task-properties[]

// tag::nested-specs[]
tasks.register('nestedSpecs', Copy) {

        given:
        buildFile '''
            task assemble(type: BreakingTask) {
                dependsOn "classes"
            }
            task generatePermissions(type: BreakingTask) {
                dependsOn "classes"
            }
            task classes(type: BreakingTask) {
                finalizedBy "assemble", "generatePermissions"
                dependsOn "compileJava", "processResources"

# Custom Response Classes - File, HTML, Redirect, Streaming, etc.

There are several custom response classes you can use to create an instance and return them directly from your *path operations*.

Read more about it in the [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.tiangolo.com/advanced/custom-response/).

You can import them directly from `fastapi.responses`:

```python
from fastapi.responses import (
    FileResponse,

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * A helper class that can remap classes loaded from the original JARs of the TransformedClassPath to the classes from the corresponding transformed JARs.
 * <p>
 * This class is thread-safe.
 */
public class TransformReplacer implements Closeable {

}


description = """Support classes used to run tests with the JUnit Platform testing framework.
This project is separate from :testing-jvm-infrastructure since it requires junit-platform which itself requires Java 8+.
This project should only be used by :testing-jvm-infrastructure, however it is not depended upon directly.

internal
class DefaultClassDecoder : ClassDecoder {

    private
    val classes = ReadIdentities()

    private
    val scopes = ReadIdentities()

    override fun ReadContext.decodeClass(): Class<*> {
        val id = readSmallInt()
        val type = classes.getInstance(id)
        if (type != null) {
            return type as Class<*>
        }
        val name = readString()

            ":compileJava", ":compileGroovy", ":processResources", ":classes", ":jar", ":assemble",
            ":compileTestJava", ":compileTestGroovy", ":processTestResources", ":testClasses", ":test", ":check",
            ":build"
        ]
        def classFile = file("build/classes/groovy/main/Thing.class")
        def testClassFile = file("build/classes/groovy/test/ThingTest.class")
        def testResults = file("build/test-results/test")

    api(project(":analysis:project-structure"))
    api(project(":analysis:analysis-api-fir"))
    api(project(":analysis:low-level-api-fir"))
    api(project(":analysis:symbol-light-classes"))
    api(project(":analysis:decompiled:light-classes-for-decompiled"))
    api(project(":analysis:analysis-api-standalone:analysis-api-standalone-base"))
    implementation(project(":analysis:analysis-api-standalone:analysis-api-fir-standalone-base"))

You can import it directly form `fastapi`:

```python
from fastapi import WebSocketDisconnect
```

::: fastapi.WebSocketDisconnect

## WebSockets - additional classes

Additional classes for handling WebSockets.

Provided directly by Starlette, but you can import it from `fastapi`:

```python
from fastapi.websockets import WebSocketDisconnect, WebSocketState
```

 */

package org.gradle.internal.instrumentation.property.upgrades;

import org.gradle.internal.instrumentation.api.annotations.VisitForInstrumentation;

/**
 * Add classes to visit to this registry to enable property upgrade instrumentation.
 *
 * Classes that should be visited should be added to the @VisitForInstrumentation annotation, e.g.
 * {@code @VisitForInstrumentation(value = {Checkstyle.class})}.
 */