// State 2: Process Type 2 and generate Type 3
        byte[] type3Token = context.initSecContext(type2Token, 0, type2Token.length);

        assertNotNull(type3Token);
        assertTrue(type3Token.length > 0);
        assertTrue(context.isEstablished());
        assertArrayEquals(serverChallenge, context.getServerChallenge());
        // Signing key may or may not be generated depending on flags negotiation

.classpath
.kotlin
.project
.settings
.gradle
eclipsebin

bin
gen
build
out
lib
generated

target
pom.xml.*
release.properties
local.properties

.vscode

.idea
*.iml
*.ipr
*.iws
*.log
classes

obj

.DS_Store

# Special Mkdocs files
docs/4.x
docs/changelog.md
docs/contributing.md
docs/index.md

# jenv
/.java-version
/site/

val testJavaVersion = System.getProperty("test.java.version", "21").toInt()

val copyResourcesTemplates = tasks.register<Copy>("copyResourcesTemplates") {
  from("src/main/resources-templates")
  into(layout.buildDirectory.dir("generated/resources-templates"))
  expand("projectVersion" to "${project.version}")
  filteringCharset = Charsets.UTF_8.toString()
}

kotlin {
  sourceSets {
    val main by getting {

 -----
 2006-11-04
 -----

Maven 4 API - Immutable Toolchains Model

 This is strictly the immutable model for Maven toolchains in <<<org.apache.maven.api.toolchain>>> package.

 The following are generated from this model:

   * {{{./apidocs/index.html}Java sources}} with <<<Builder>>> inner classes for immutable instances creation.

					fmt.Errorf("%s claim missing from the JWT token, credentials will not be generated", iamPolicyClaimNameOpenID()))
				return
			} else if policyName == "" {
				writeSTSErrorResponse(ctx, w, ErrSTSInvalidParameterValue,
					fmt.Errorf("None of the given policies (`%s`) are defined, credentials will not be generated", policies))
				return
			}
		}
		claims[iamPolicyClaimNameOpenID()] = policyName
	}

                ).joinToString(" "),
        )

        setArtifactRules(
            """$artifactRules
platforms/core-runtime/base-services/build/generated-resources/build-receipt/org/gradle/build-receipt.properties
""",
        )
    }) {
    companion object {
        fun buildTypeId(model: CIBuildModel) = buildTypeId(model.projectId)

└── fess_indices/              # OpenSearch index mappings

src/main/webapp/WEB-INF/view/  # JSP templates
```

## DBFlute Code Generation

DBFlute generates type-safe data access code for OpenSearch indices:

```bash
mvn dbflute:freegen
```

Generated code:
- `opensearch/{index}/bsentity/` - Base entities (do not edit)
- `opensearch/{index}/exentity/` - Extended entities (customize here)

  public void testStringArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    String[] a1 = generator.generateFresh(String[].class);
    String[] a2 = generator.generateFresh(String[].class);
    assertFalse(a1[0].equals(a2[0]));
  }

  public void testPrimitiveArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    int[] a1 = generator.generateFresh(int[].class);

import org.gradle.api.Project
import org.gradle.api.file.SourceDirectorySet

import org.gradle.kotlin.dsl.*
import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension


// TODO these accessors should be generated - https://github.com/gradle/gradle/issues/3191

val Project.kotlinMainSourceSet: SourceDirectorySet

There are multiple tools that you can use to create those dependables, and they get integrated into OpenAPI so they are shown in the automatic docs UI, they can be used by automatically generated clients and SDKs, etc.

You can import them from `fastapi.security`:

```python
from fastapi.security import (
    APIKeyCookie,
    APIKeyHeader,
    APIKeyQuery,
    HTTPAuthorizationCredentials,