final List<Role> list = roleService.getRoleList(pager);
        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount()).status(ApiResult.Status.OK).result());
    }

    // GET /api/admin/role/setting/{id}
    @Execute

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    assertEquals(2, sessionIds.size)
    val directSessionIds =
      sslContext.clientSessionContext.ids.toList().map { it.toByteString().hex() }

    if (platform.isConscrypt()) {
      if (tlsVersion == TlsVersion.TLS_1_3) {
        assertThat(sessionIds[0]).isEmpty()
        assertThat(sessionIds[1]).isEmpty()

        return collectMapIfPresentOrEmpty(Options::userProperties);
    }

    @Override
    public String source() {
        return String.format(
                "layered(%s)", options.stream().map(Options::source).toList());
    }

    @Override
    public Optional<Boolean> showVersionAndExit() {
        return returnFirstPresentOrEmpty(Options::showVersionAndExit);
    }

    @Override

            };
        } else {
            return null;
        }
    }

    private List<SettingsProblem> convert(List<BuilderProblem> problems) {
        return problems.stream().map(this::convert).toList();
    }

    private SettingsProblem convert(BuilderProblem problem) {
        return new DefaultSettingsProblem(
                problem.getMessage(),

        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount()).status(ApiResult.Status.OK).result());
    }

    // GET /api/admin/scheduler/setting/{id}
    @Execute

  for (i in 0 until size) {
    if (name.equals(name(i), ignoreCase = true)) {
      if (result == null) result = ArrayList(2)
      result.add(value(i))
    }
  }
  return result?.toList().orEmpty()
}

internal fun Headers.commonIterator(): Iterator<Pair<String, String>> {
  return Array(size) { name(it) to value(it) }.iterator()
}

internal fun Headers.commonNewBuilder(): Headers.Builder {

        final List<WebConfig> list = webConfigService.getWebConfigList(pager);
        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount()).status(ApiResult.Status.OK).result());
    }

    // GET /api/admin/webconfig/setting/{id}
    @Execute

                .peek(l -> Objects.requireNonNull(l.getId(), "A lifecycle must have an id."))
                .sorted(Comparator.comparing(Lifecycle::getId, comparator))
                .collect(Collectors.toList());
    }

    private Map<String, Lifecycle> lookupLifecycles() {
        // TODO: Remove the following code when maven-compat is gone

        final List<BadWord> list = badWordService.getBadWordList(pager);
        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount()).status(ApiResult.Status.OK).result());
    }

    // GET /api/admin/badword/{id}
    @Execute
    public JsonResponse<ApiResult> get$setting(final String id) {

            result.setActivePomProfiles(
                    modelId, activePomProfiles.stream().map(Profile::new).collect(Collectors.toList()));
            modelv4 = profileInjector.injectProfiles(modelv4, activePomProfiles, request, problems);
            if (currentData == resultData) {
                for (Profile activeProfile : activeExternalProfiles) {