override suspend fun WriteContext.encode(value: AbstractTransformedArtifactSet.CalculateArtifacts) {
        write(value.ownerId)
        write(value.targetVariantAttributes)
        writeCollection(value.capabilities.asSet())
        val files = mutableListOf<Artifact>()
        value.delegate.visitExternalArtifacts { files.add(Artifact(file, artifactName.classifier)) }
        write(files)
        val steps = unpackTransformSteps(value.steps)

        } else {
            return new DefaultImmutableCapability(capability.getGroup(), capability.getName(), capability.getVersion());
        }
    }

    public ImmutableSet<ImmutableCapability> asSet() {
        return capabilities;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {

    override suspend fun WriteContext.encode(value: TransformingAsyncArtifactListener.TransformedArtifact) {
        write(value.variantName)
        write(value.target)
        writeCollection(value.capabilities.asSet())
        write(value.artifact.id.componentIdentifier)
        write(value.artifact.file)
        write(unpackTransformSteps(value.transformSteps))
    }

        ImmutableSet<ImmutableCapability> providerCapabilitiesSet = providerCapabilities.asSet();
        if (providerCapabilitiesSet.isEmpty()) {
            // producer doesn't declare anything, so we assume that it only provides the implicit capability
            if (explicitRequestedCapabilities.size() == 1) {

        usedVersions = new TreeSet<>();
        for (GradleVersion gradleVersion : getUsedGradleVersionsSmallerThanCurrent()) {
            usedVersions.addAll(cacheVersionMapping.getVersionUsedBy(gradleVersion).asSet());
        }
    }

    private SortedSet<GradleVersion> getUsedGradleVersionsSmallerThanCurrent() {
        return usedGradleVersions.getUsedGradleVersions().headSet(GradleVersion.current());
    }

    @Override

// Creates a pass that freezes tf_saved_model.global_tensor ops.
std::unique_ptr<OperationPass<ModuleOp>> CreateFreezeGlobalTensorsPass(
    bool allow_mutable_tensors = false);

// Creates a pass that freezes tf_saved_model.asset ops.
std::unique_ptr<OperationPass<ModuleOp>> CreateFreezeAssetsPass(
    std::string saved_model_dir = "");

// Creates as pass that removes variables in the session initializer.

        artifactResolver.resolveArtifactsWithType(getArtifactMetadata(), artifactType, result);
    }

    protected ImmutableCapabilities capabilitiesFor(ImmutableCapabilities capabilities) {
        if (capabilities.asSet().isEmpty()) {
            return ImmutableCapabilities.of(DefaultImmutableCapability.defaultCapabilityForComponent(getMetadata().getModuleVersionId()));
        } else {
            return capabilities;
        }
    }

// imported from saved model version one and utilized for capturing resource
// variables. If the `saved_model_dir` directory path is provided, then the
// `tf_saved_model.asset` ops will be freezed.
void AddTFToTFLConversionPasses(llvm::StringRef saved_model_dir,
                                const toco::TocoFlags& toco_flags,
                                const mlir::TFL::PassConfig& pass_config,

        formatter.append("'");
        formatter.append(" " + CapabilitiesDescriber.describeCapabilitiesWithTitle(targetComponentId, assessedCandidate.getCandidateCapabilities().asSet()));

        formatAttributeMatchesForAmbiguity(assessedCandidate, formatter, describer);
    }

      if (assets_iter == objects.assets.end()) {
        return absl::FailedPreconditionError(absl::StrCat(
            "Tried to convert node id ", node_id,
            " of type asset to tensor but the asset wasn't initialized"));
      }
      *handle = assets_iter->second->handle();
      return Status();
    }
    case SavedObject::kResource: {