api(project(":core-api"))
    api(project(":dependency-management"))

    api(libs.guava)
    api(libs.inject)

    implementation(projects.stdlibJavaExtensions)
    implementation(project(":logging-api"))
    implementation(project(":platform-base"))
    implementation(project(":platform-jvm"))

    runtimeOnly(libs.groovy)

    integTestImplementation(testFixtures(project(":core")))

    }
    pluginsRuntimeOnly(project(":composite-builds")) {
        because("We always need a BuildStateRegistry service implementation for certain code in ':core' to work.")
    }
    pluginsRuntimeOnly(project(":tooling-api-builders")) {
        because("We always need a BuildEventListenerFactory service implementation for ':launcher' to create global services.")
    }
    pluginsRuntimeOnly(project(":version-control")) {

    api(project(":publish"))
    api(project(":resources"))

    api(libs.jsr305)
    api(libs.inject)

    implementation(project(":functional"))
    implementation(project(":logging-api"))

    implementation(libs.guava)
    implementation(libs.commonsLang)
    implementation(libs.ivy)

    testImplementation(project(":native"))
    testImplementation(project(":process-services"))

    return delegate().descendingMultiset();
  }

  /**
   * A skeleton implementation of a descending multiset view. Normally, {@link
   * #descendingMultiset()} will not reflect any changes you make to the behavior of methods such as
   * {@link #add(Object)} or {@link #pollFirstEntry}. This skeleton implementation correctly
   * delegates each of its operations to the appropriate methods of this {@code

}

description = "Local build cache implementation"

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":build-cache"))
    api(project(":build-cache-spi"))
    api(project(":files"))
    api(project(":functional"))
    api(project(":hashing"))
    api(project(":persistent-cache"))

    implementation(libs.commonsIo)
    implementation(libs.guava)

    api(project(":core-api"))
    api(project(":core"))

    implementation(libs.guava)
    implementation(libs.slf4jApi)
    implementation(project(":io"))
    implementation(project(":enterprise-logging"))

    testImplementation(testFixtures(project(":serialization")))

dependencies {
    api(project(":base-services"))
    api(project(":model-core"))
    api(project(":base-services-groovy"))

    api(libs.jsr305)
    api(libs.groovy)

    implementation(projects.stdlibJavaExtensions)
    implementation(project(":core-api"))

    implementation(libs.guava)

    testImplementation(testFixtures(project(":core")))
    testImplementation(testFixtures(project(":model-core")))

    api(project(":platform-base"))
    api(project(":platform-native"))
    api(project(":service-provider"))

    implementation(project(":model-core"))
    implementation(project(":testing-native"))
    implementation(project(":logging-api"))
    implementation(libs.commonsLang)

    runtimeOnly(project(":dependency-management"))
    runtimeOnly(project(":testing-base"))

   */
  @RestrictedApi(
      explanation = "PatternCompiler is an implementation detail of com.google.common.base",
      allowedOnPath = ".*/com/google/common/base/.*")
  CommonPattern compile(String pattern);

  /**
   * Returns {@code true} if the regex implementation behaves like Perl -- notably, by supporting
   * possessive quantifiers but also being susceptible to catastrophic backtracking.

   */
  @RestrictedApi(
      explanation = "PatternCompiler is an implementation detail of com.google.common.base",
      allowedOnPath = ".*/com/google/common/base/.*")
  CommonPattern compile(String pattern);

  /**
   * Returns {@code true} if the regex implementation behaves like Perl -- notably, by supporting
   * possessive quantifiers but also being susceptible to catastrophic backtracking.