if (e.key === 'Enter' && !e.shiftKey && !e.isComposing) {
                e.preventDefault();
                sendMessage();
            }
        });

        // Handle IME composition for older browsers
        elements.chatInput.on('compositionstart', function() {
            elements.chatInput.data('composing', true);
        });
        elements.chatInput.on('compositionend', function() {

        "parallelizationMethod": {
          "name": "TestDistribution"
        }
      },
      {
        "subprojects": [
          "build-cache-example-client",
          "client-services",
          "composite-builds",
          "docs",
          "files",
          "model-reflect",
          "request-handler-worker",
          "security",
          "service-registry-impl",
          "stdlib-java-extensions",

    docsTestProject: DocsTestProject,
) : OsAwareBaseGradleBuildType(os = docsTestProject.os, init = {
        id("${asDocsTestId(model, os)}_Trigger")
        name = docsTestProject.name + " (Trigger)"
        type = Type.COMPOSITE

        applyDefaultSettings()

        dependencies {
            snapshotDependencies(docsTestProject.docsTests)
        }
    })

enum class DocsTestType(
    val ccEnabled: Boolean,

        id(stageTriggerId(model, stage, os))
        uuid = stageTriggerUuid(model, stage, os)
        name = stage.stageName.stageName + " (Trigger)" + (os?.asName()?.toCapitalized()?.let { "($it)" } ?: "")
        type = Type.COMPOSITE

        applyDefaultSettings()

        features {
            publishBuildStatusToGithub(model)
        }

        if (generateTriggers) {

#### Software development platform

This is a general purpose platform that builds on the core automation platform to add support for the automation of software development.
This includes work such as compiling, testing and documenting software, plus sharing that software via publishing and dependency management.
This platform is agnostic to what kind of software is being developed.

* Bridging with Kotlin code is polluted with platform types
* Some public APIs have incorrect nullability annotations (both overly restrictive and overly permissive)

While there are competing ways to represent absence (`Optional`, "Null Object" pattern, method overloads),
it is unlikely that we'll be able to remove `null` entirely.

        id("${model.projectId}_FlakyQuarantine_${flakyTestQuarantineProject.os.asName()}_Trigger")

        name = flakyTestQuarantineProject.name + " (Trigger)"
        type = Type.COMPOSITE

        applyDefaultSettings()

        dependencies {
            snapshotDependencies(
                flakyTestQuarantineProject.buildTypes.map {
                    it as BaseGradleBuildType

    "name": "collections",
    "path": "platforms/core-runtime/collections",
    "unitTests": true,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "composite-builds",
    "path": "subprojects/composite-builds",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "concurrent",
    "path": "platforms/core-runtime/concurrent",

    }

    requirements {
        requiresOs(os)
        requiresArch(os, arch)
    }

    failureConditions {
        if (******@****.*** != BuildTypeSettings.Type.COMPOSITE) {
            executionTimeoutMin = timeout
        }
        testFailure = true
        supportTestRetry = true
        add {
            failOnText {

            for (final File file : jarFiles) {
                list.add(getArtifactFromFileName(artifactType, file.getName()));
            }
            list.sort(Comparator.comparing(Artifact::getName));
            return list.toArray(new Artifact[list.size()]);
        }

        final File[] jarFiles = ResourceUtil.getPluginJarFiles(artifactType.getId());