validations:
      required: true
  - type: input
    id: build-scan-url
    attributes:
      label: Build scan URL (optional)
      description: |
        You can run your build command with `--scan` to publish a Build Scan to [scans.gradle.com](https://scans.gradle.com/).
    validations:
      required: false
  - type: textarea
    id: environment
    attributes:
      label: Your Environment (optional)

            }
        }
    }
}

fun BuildFeatures.publishBuildStatusToGithub() {
    if (VersionedSettingsBranch.fromDslContext().isExperimental) {
        // don't publish xperimental commit status that might bother developer
        return
    }

    commitStatusPublisher {
        vcsRootExtId = VersionedSettingsBranch.fromDslContext().vcsRootId()
        publisher =

                    + "the Software without restriction, including without limitation the rights to\n"
                    + "use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\n"
                    + "of the Software, and to permit persons to whom the Software is furnished to do\n"
                    + "so, subject to the following conditions:\n"

    when {
      level.intValue() > Level.INFO.intValue() -> Log.WARN
      level.intValue() == Level.INFO.intValue() -> Log.INFO
      else -> Log.DEBUG
    }

object AndroidLogHandler : Handler() {
  override fun publish(record: LogRecord) {
    androidLog(record.loggerName, record.androidLevel, record.message, record.thrown)
  }

  override fun flush() {
  }

  override fun close() {
  }
}

@SuppressSignatureCheck

    tag OS.current().name()
    tag Architecture.current().name()

    // Tag if this build is run in FIPS mode
    if (BuildParams.inFipsJvm) {
      tag 'FIPS'
    }

    // Automatically publish scans from Elasticsearch CI
    if (jenkinsUrl?.host?.endsWith('elastic.co') || jenkinsUrl?.host?.endsWith('elastic.dev')) {
      publishAlways()
      buildScan.server = 'https://gradle-enterprise.elastic.co'
    }

 *
 * <h2>EventBus Summary</h2>
 *
 * <p>The EventBus allows publish-subscribe-style communication between components without requiring
 * the components to explicitly register with one another (and thus be aware of each other). It is
 * designed exclusively to replace traditional Java in-process event distribution using explicit
 * registration. It is not a general-purpose publish-subscribe system, nor is it intended
 * for interprocess communication.

Provides build logic, libraries, test suites and infrastructure to support developing and releasing Gradle.

#### Documentation

Provides cross-cutting Gradle documentation and samples, along with the infrastructure to write, test, publish and host the documentation.

## Consequences

- Assign ownership of each architecture module to one team.
- Assign each source file to one architecture module.
- Align the source tree layout with this architecture.

                  <div class="well">
                    Sometimes, the change was made on the `release` branch but hasn't yet been published to the baseline version.
                    In that case, you can publish a new snapshot from the release branch. This will update `released-versions.json` on `master`.

   * retries all must complete within one timeout period.
   *
   * Configure the client's default timeout with [OkHttpClient.Builder.callTimeout].
   */
  fun timeout(): Timeout

  /**
   * Configure this call to publish all future events to [eventListener], in addition to the
   * listeners configured by [OkHttpClient.Builder.eventListener] and other calls to this function.
   *

       */

      //
      seenExceptionsLocal = newConcurrentHashSet();
      /*
       * Other handleException() callers may see this as soon as we publish it. We need to populate
       * it with the initial failure before we do, or else they may think that the initial failure
       * has never been seen before.
       */
      addInitialException(seenExceptionsLocal);