def locations = ['/my/path', '/my/sibling', '/my/path/some/child']
        updateVersions('/my/path', '/my/sibling', '/my/path/some/child')

        when:
        def rootVersionBefore = getVersion('')
        then:
        getVersion('/') == rootVersionBefore

        when:
        updateVersions(root)
        then:

        updateVersions(preferredVersion, requiredVersion, strictVersion);
        for (String reject : rejects) {
            this.rejectedVersions.add(nullToEmpty(reject));
        }
        this.branch = branch;
    }

    private void updateVersions(@Nullable String preferredVersion, @Nullable String requiredVersion, @Nullable String strictVersion) {

    @get:Internal
    abstract val releasedVersionsFile: RegularFileProperty

    @get:Internal
    abstract val currentReleasedVersion: Property<ReleasedVersion>

    @TaskAction
    fun updateVersions() {
        val currentReleasedVersionValue = currentReleasedVersion.get()
        val releasedVersionsFileObject = releasedVersionsFile.get().asFile

     */
    @CheckReturnValue
    public VersionHierarchyRoot updateVersion(String location) {
        long newVersion = rootNode.getMaxVersionInHierarchy() + 1;
        VfsRelativePath relativePath = VfsRelativePath.of(location);
        VersionHierarchy newRootNode = relativePath.isEmpty()
            ? VersionHierarchy.empty(newVersion)
            : rootNode.updateVersion(relativePath, newVersion, caseSensitivity);

     *
     * @param newVersion The new version. Must be bigger than the current maximum version in this hierarchy.
     */
    @CheckReturnValue
    public VersionHierarchy updateVersion(VfsRelativePath relativePath, long newVersion, CaseSensitivity caseSensitivity) {
        ChildMap<VersionHierarchy> newChildren = children.store(relativePath, caseSensitivity, new ChildMap.StoreHandler<VersionHierarchy>() {

    /** {@inheritDoc} */
    public ArtifactRepository getRepository() {
        return artifact.getRepository();
    }

    /** {@inheritDoc} */
    public void updateVersion(String version, ArtifactRepository localRepository) {
        artifact.updateVersion(version, localRepository);
    }

    /** {@inheritDoc} */
    public String getDownloadUrl() {
        return artifact.getDownloadUrl();
    }

                    throw new ArtifactNotFoundException("Unable to determine the latest version", artifact);
                }

                artifact.setBaseVersion(version);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

                    throw new ArtifactNotFoundException("Unable to determine the release version", artifact);
                }

                artifact.setBaseVersion(version);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

                result = updateNotifyingListeners(diffListener -> currentRoot.invalidate(location, diffListener));
                newVersionHierarchyRoot = newVersionHierarchyRoot.updateVersion(location);
            }
            versionHierarchyRoot = newVersionHierarchyRoot;
            return result;
        });
    }

    @Override
    public void invalidateAll() {

    Collection<ArtifactMetadata> getMetadataList();

    void setRepository(ArtifactRepository remoteRepository);

    ArtifactRepository getRepository();

    void updateVersion(String version, ArtifactRepository localRepository);

    String getDownloadUrl();

    void setDownloadUrl(String downloadUrl);

    ArtifactFilter getDependencyFilter();