translate:
    if: github.repository_owner == 'fastapi'
    needs: langs
    runs-on: ubuntu-latest
    strategy:
      matrix:
        lang: ${{ fromJson(needs.langs.outputs.langs) }}
        command: ${{ fromJson(needs.langs.outputs.commands) }}
    permissions:
      contents: write
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}

        if (response.statusCode() > 399) {
            throw RuntimeException("Failed to fetch versions from Gradle services: ${response.statusCode()} ${response.body()}")
        }
        val versions = Gson().fromJson(response.body(), Array<GradleServicesVersion>::class.java)
        val found = versions.find { it.version == targetVersion }
            ?: throw RuntimeException("Version $targetVersion not found at $uri")

}


fun updateReleasedVersionFile(releasedVersionsFile: File, currentReleasedVersion: ReleasedVersion) {
    val releasedVersions = releasedVersionsFile.reader().use {
        Gson().fromJson(it, ReleasedVersions::class.java)
    }
    val newReleasedVersions = updateReleasedVersions(currentReleasedVersion, releasedVersions)

  build-docs:
    needs:
      - changes
      - langs
    if: ${{ needs.changes.outputs.docs == 'true' }}
    runs-on: ubuntu-latest
    strategy:
      matrix:
        lang: ${{ fromJson(needs.langs.outputs.langs) }}
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - uses: actions/checkout@v6

  unit-test:
    name: "${{ matrix.bucket.name }} (Unit Test)"
    permissions:
      contents: read
    runs-on: ubuntu-latest
    needs: build
    strategy:
      matrix:
        bucket: ${{ fromJson(needs.build.outputs.matrix) }}
      fail-fast: false
    steps:
      - name: git clone
        uses: actions/checkout@v6
      - name: setup java
        uses: actions/setup-java@v5
        with:

    JsonReader(source.reader(Charsets.UTF_8)).use { reader ->
        reader.strictness = Strictness.LENIENT
        return Gson().fromJson(reader)
    }
}

inline
fun <reified T> Gson.fromJson(json: JsonReader): T = this.fromJson(json, object : TypeToken<T>() {}.type)


abstract class CapabilityRule @Inject constructor(
    val name: String,
    val version: String

        if (response.statusCode() > 399) {
            throw RuntimeException("Failed to get issues: $uri ${response.statusCode()} ${response.body()}")
        }
        return Gson().fromJson(response.body(), GitHubIssueSearchResult::class.java).items
    }

    private
    fun updateReleaseNotes(issuesList: String) {
        val notesFile = releaseNotes.asFile.get()

        if (!file.exists()) {
            return Collections.emptyList();
        }
        try (FileReader reader = new FileReader(file)) {
            List<UpgradedProperty> upgradedProperties = new Gson().fromJson(reader, new TypeToken<List<UpgradedProperty>>() {}.getType());
            // FIXME There should be no duplicates, yet there are some
            return upgradedProperties.stream()
                .distinct()

    val response = client.newCall(request).execute()

    val results =
      response.use {
        moshi.adapter(HowsMySslResults::class.java).fromJson(response.body.string())!!
      }

    Platform.get().log("results $results", Platform.WARN)

    assertTrue(results.session_ticket_supported)
    assertEquals("Probably Okay", results.rating)

                val detailsFile = detailsFiles[i]
                val buildFile = buildFiles[i]

                val details = detailsFile.bufferedReader().use {
                    gson.fromJson(it, TargetRuntimeDetails::class.java)
                }
                projects[path] = ProjectInfo(details, buildFile)
            }
        }

        return projects
    }

    /**