def acceptedApiChanges = new AcceptedApiChanges()
        acceptedApiChanges.acceptedChanges = [:]
        for (String jsonText : jsonTexts) {
            def json = new Gson().fromJson(jsonText, new TypeToken<Map<String, List<AcceptedApiChange>>>() {}.type)
            Map<ApiChange, String> acceptedChanges = json.acceptedApiChanges.collectEntries { jsonChange ->

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.slack;

import com.squareup.moshi.FromJson;
import com.squareup.moshi.JsonAdapter;
import com.squareup.moshi.Moshi;
import com.squareup.moshi.ToJson;
import java.io.IOException;
import okhttp3.Call;
import okhttp3.HttpUrl;
import okhttp3.WebSocket;

          @FromJson fun byteStringFromJson(json: String) = json.decodeHex()
        },
      ).add(KotlinJsonAdapterFactory())
      .build()
  private val STORY_JSON_ADAPTER = MOSHI.adapter(Story::class.java)

  private val fileSystem = FileSystem.SYSTEM

  private fun readStory(source: BufferedSource): Story = STORY_JSON_ADAPTER.fromJson(source)!!

  private fun readStory(file: Path): Story {

    }

    tasks.register(configureWrapperTaskName) {
        doLast {
            val jsonText = URI("https://services.gradle.org/versions/$label").toURL().readText()
            val versionInfo = Gson().fromJson(jsonText, VersionDownloadInfo::class.java)
            println("updating wrapper to $label version: ${versionInfo.version} (downloadUrl: ${versionInfo.downloadUrl})")

    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

        List<String> missingFiles = new ArrayList<>();

        Gson gson = new Gson();
        List<AdocFileEntry> entries;
        try (FileReader reader = new FileReader(jsonFile)) {
            entries = gson.fromJson(reader, new TypeToken<List<AdocFileEntry>>() {}.getType());
        }

        Set<String> foundAdocFiles = new HashSet<>();
        try (Stream<Path> pathStream = Files.walk(Paths.get(directoryPath))) {

  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) }}

        .build()
    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      val gist = gistJsonAdapter.fromJson(response.body!!.source())

      for ((key, value) in gist!!.files!!) {
        println(key)
        println(value.content)
      }
    }
  }

  @JsonClass(generateAdapter = true)
  data class Gist(

        .build();
    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      Gist gist = gistJsonAdapter.fromJson(response.body().source());

      for (Map.Entry<String, GistFile> entry : gist.files.entrySet()) {
        System.out.println(entry.getKey());
        System.out.println(entry.getValue().content);
      }
    }
  }

        parallelizationMethod,
    )

    constructor(jsonObject: Map<String, Any>) : this(
        (jsonObject["subprojects"] as List<*>).map { it.toString() },
        ParallelizationMethod.fromJson(jsonObject),
    )

    fun toBuildTypeBucket(gradleSubprojectProvider: GradleSubprojectProvider): SmallSubprojectBucket =
        SmallSubprojectBucket(