import javax.annotation.Nullable;

public class DependencyModel extends AbstractContextAwareModel {
    private final String group;
    private final String name;
    private final ImmutableVersionConstraint version;
    private final String versionRef;
    private final int hashCode;

    public DependencyModel(String group,
                           String name,

import org.gradle.api.provider.ValueSourceParameters;

public abstract class DependencyValueSource implements ValueSource<DependencyModel, DependencyValueSource.Params> {

    interface Params extends ValueSourceParameters {
        Property<DependencyModel> getDependencyData();
    }

    @Override
    public DependencyModel obtain() {
        return getParameters().getDependencyData().get();
    }

public class DefaultVersionCatalog implements Serializable {
    private final String name;
    private final String description;
    private final Map<String, DependencyModel> libraries;
    private final Map<String, BundleModel> bundles;
    private final Map<String, VersionModel> versions;
    private final Map<String, PluginModel> plugins;

    private final int hashCode;

public abstract class DependencyBundleValueSource implements ValueSource<List<DependencyModel>, DependencyBundleValueSource.Params> {

    interface Params extends ValueSourceParameters {
        Property<String> getBundleName();

        Property<DefaultVersionCatalog> getConfig();
    }

    @Override
    public List<DependencyModel> obtain() {
        String bundle = getParameters().getBundleName().get();

            ImmutableVersionConstraint version = owner.versionConstraintInterner.intern(DefaultImmutableVersionConstraint.of(versionBuilder));
            DependencyModel model = new DependencyModel(owner.intern(group), owner.intern(name), null, version, owner.currentContext);
            Supplier<DependencyModel> previous = owner.libraries.put(owner.intern(alias), () -> model);
            if (previous != null) {

            @Override
            public MinimalExternalModuleDependency transform(DependencyModel x) {
                return createMinimalDependency(x, attributesFactory, capabilityNotationParser, objects);
            }
        });
    }

package org.gradle.api.plugins.catalog.internal;

import org.gradle.api.internal.artifacts.ImmutableVersionConstraint;
import org.gradle.api.internal.catalog.DefaultVersionCatalog;
import org.gradle.api.internal.catalog.DependencyModel;
import org.gradle.api.internal.catalog.PluginModel;
import org.gradle.api.internal.catalog.parser.TomlCatalogFileParser;

import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

        Paths.get(tomlResource)
    }

    @CompileStatic
    private static class DependencySpec {
        private final DependencyModel model

        DependencySpec(DependencyModel model) {
            this.model = model
        }

        void withGroup(String group) {
            assert model.group == group
        }

                DependencyModel model = config.getDependencyData(path);
                writeDependencyAccessor(path, model, true, deprecated);
            }
            for (String alias : classNode.aliases) {
                String childName = leafNodeForAlias(alias);
                if (!classNode.hasChild(childName)) {
                    DependencyModel model = config.getDependencyData(alias);