List<Path> paths = session.resolveDependencies(coord);

        assertNotNull(paths);
        assertEquals(10, paths.size());
        assertEquals("test-extension-1.jar", paths.get(0).getFileName().toString());

        // JUnit has an "Automatic-Module-Name", so it appears on the module path.
        Map<PathType, List<Path>> dispatched = session.resolveDependencies(

/**
 * Postprocesses filesystem paths. For instance, a path translator might want to resolve relative paths given in the
 * bean configuration against some base directory.
 *
 */
public interface BeanConfigurationPathTranslator {

    /**
     * Translates the specified path.
     *
     * @param path The path to translate, may be {@code null}.
     * @return The translated path or {@code null} if none.
     */

        @Override
        public Model getRawModel(Path from, String groupId, String artifactId) throws IllegalStateException {
            throw new UnsupportedOperationException();
        }

        @Override
        public Model getRawModel(Path from, Path p) {
            throw new UnsupportedOperationException();
        }

        @Override
        public Path locate(Path path) {

class ComparableVersionIT {

    @Test
    void test() throws Exception {
        Files.walkFileTree(Paths.get("target"), new SimpleFileVisitor<Path>() {
            Pattern mavenArtifactJar = Pattern.compile("maven-artifact-[\\d.]+(-SNAPSHOT)?\\.jar");

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                String filename = file.getFileName().toString();

#     <type> <name>
#
# Type can be:
#    path - an exact path to a single file
#    file-name - an exact leaf filename, regardless of path
#    path-prefix - a prefix match on the file path
#    file-prefix - a prefix match of the leaf filename (no path)
#    paths-from-repo - read a file from the repo and load file paths
#

file-prefix	zz_generated.

file-name	types.generated.go

            try {
                if (count < 10) {
                    System.out.println(path);
                }
                System.out.println(path);
                assertThat(path, is(notNullValue()));
                assertThat(path, path.startsWith("junit") || path.startsWith("org/junit") || path.startsWith("org/hamcrest")

     *            translation.
     */
    public BasedirBeanConfigurationPathTranslator(File basedir) {
        this.basedir = basedir;
    }

    public File translatePath(File path) {
        File result = path;

        if (path != null && basedir != null) {
            if (path.isAbsolute()) {
                // path is already absolute, we're done

     * or on the module-path when the {@code "jar"} artifact type is used.
     */
    private PathType getPathType(Path path) throws IOException {
        PathType type = pathTypes.get(path);
        if (type == null) {
            type = new PathModularization(path, false).getPathType();
            pathTypes.put(path, type);
        }
        return type;
    }

        BeanConfigurationPathTranslator translator = path -> new File("base", path.getPath()).getAbsoluteFile();

        DefaultBeanConfigurationRequest request = new DefaultBeanConfigurationRequest();
        request.setBean(bean).setConfiguration(config);
        request.setValuePreprocessor(preprocessor).setPathTranslator(translator);

        configurator.configureBean(request);

        assertEquals(Paths.get("base/test").toAbsolutePath(), bean.file);

    """
    new_path: Path = Path("docs") / lang
    if new_path.exists():
        typer.echo(f"The language was already created: {lang}")
        raise typer.Abort()
    new_path.mkdir()
    new_config_path: Path = Path(new_path) / mkdocs_name
    new_config_path.write_text("INHERIT: ../en/mkdocs.yml\n", encoding="utf-8")
    new_config_docs_path: Path = new_path / "docs"
    new_config_docs_path.mkdir()