testJvmVendorParameter,
            JvmVendor.openjdk.name,
            display = ParameterDisplay.PROMPT,
            description = "Java vendor to run the test with",
            options = JvmVendor.values().map { it.displayName to it.name }
        )
        text(
            testTaskOptionsParameterName,
            "",
            display = ParameterDisplay.PROMPT,
            allowEmpty = true,

            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.VALUE_CLASS_NOT_TOP_LEVEL) { firDiagnostic ->
        ValueClassNotTopLevelImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.VALUE_CLASS_NOT_FINAL) { firDiagnostic ->
        ValueClassNotFinalImpl(
            firDiagnostic as KtPsiDiagnostic,

    type annotation for variables representing a Tensor or a value that can be
    converted to Tensor by `tf.convert_to_tensor`.
*   Calling ops with a python constants or numpy values is now consistent with
    tf.convert_to_tensor behavior. This avoids operations like tf.reshape
    truncating inputs such as from int64 to int32.
*   Adds `tf.sparse.map_values` to apply a function to the `.value`s of
    `SparseTensor` arguments.

canonicalizing values (like "interning" or "hash-consing").

Any value of comparable type may be canonicalized with the new
`Make[T]` function, which produces a reference to a canonical copy of
the value in the form of a `Handle[T]`.
Two `Handle[T]` are equal if and only if the values used to produce the
handles are equal, allowing programs to deduplicate values and reduce
their memory footprint.

  They are replaced in Maven 4 with Maven 4 API Core's {{{../api/maven-api-core/apidocs/org/apache/maven/api/Type.html}Dependency Types}},
  with default values defined in {{{../maven-resolver-provider/apidocs/org/apache/maven/repository/internal/type/DefaultTypeProvider.html}DefaultTypeProvider}}.

  For compatibility, legacy Maven 3 artifact handlers are still provided:

Algorithms are comma separated. 
Note that valid values does not in all cases represent default values.

`--sftp=pub-key-algos=...` specifies the supported client public key
authentication algorithms. Note that this doesn't include certificate types
since those use the underlying algorithm. This list is sent to the client if
it supports the server-sig-algs extension. Order is irrelevant.

Valid values
```
ssh-ed25519

        val token = builder.token

        listOf(
            KtNamedAnnotationValue(
                name = annotationParameterName,
                expression = KtArrayAnnotationValue(
                    values = map {
                        KtEnumEntryAnnotationValue(
                            callableId = CallableId(
                                classId = expectedEnumClassId,

    }

    private fun renderConstantValueDebug(value: KtAnnotationValue, printer: PrettyPrinter) {
        when (value) {
            is KtAnnotationApplicationValue -> {
                renderAnnotationDebug(value.annotationValue.classId, value.annotationValue.arguments, printer)
            }

            is KtArrayAnnotationValue -> {
                printer.printCollection(value.values, separator = ", ", prefix = "[", postfix = "]") {

Errors are the only type of issues that must be resolved for the `checkBinaryCompatibility` task to succeed.

You can set the 'bin.cmp.report.severity.filter' property in your `gradle.properties` to one of the available values in the dropdown box to automatically filter issues to that severity level upon opening this report.

#### Accepting multiple changes

    * Add support for enumerations in *path operation* parameters. New documentation: [Path Parameters: Predefined values](https://fastapi.tiangolo.com/tutorial/path-params/#predefined-values).