}

    @Nullable
    ModelSource resolve(@Nonnull ModelLocator modelLocator, @Nonnull String relative);

    @Nonnull
    static ModelSource fromPath(@Nonnull Path path) {
        return fromPath(path, null);
    }

    @Nonnull
    static ModelSource fromPath(@Nonnull Path path, @Nullable String location) {
        return new PathSource(nonNull(path, "path cannot be null"), location);
    }

    @Nonnull
    static SettingsBuilderRequest build(
            @Nonnull Session session, @Nonnull Path installationSettingsPath, @Nonnull Path userSettingsPath) {
        return build(session, Source.fromPath(installationSettingsPath), null, Source.fromPath(userSettingsPath));
    }

    @Nonnull
    static SettingsBuilderRequest build(
            @Nonnull Session session,
            @Nullable Source installationSettingsSource,

                                ? Source.fromPath(installationToolchainsFile)
                                : null)
                .userToolchainsSource(
                        userToolchainsPath != null && Files.exists(userToolchainsPath)
                                ? Source.fromPath(userToolchainsPath)
                                : null)
                .build();
    }

        @Override
        public String getLocation() {
            return src.toString();
        }

        @Override
        public Source resolve(String relative) {
            return ModelSource.fromPath(path.resolve(relative));
        }

        @Override
        public ModelSource resolve(ModelLocator locator, String relative) {

        if (file != null && file.exists()) {
            return org.apache.maven.api.services.Source.fromPath(file.toPath());
        } else if (source instanceof FileSource fs) {
            return org.apache.maven.api.services.Source.fromPath(fs.getPath());
        } else if (source != null) {
            return new org.apache.maven.api.services.Source() {
                @Override

        }
    }

    private Source convert(org.apache.maven.building.Source source) {
        if (source instanceof FileSource fs) {
            return Source.fromPath(fs.getPath());
        } else if (source != null) {
            return new Source() {
                @Override
                public Path getPath() {
                    return null;
                }

func (w *Walker) ImportFrom(fromPath, fromDir string, mode types.ImportMode) (*types.Package, error) {
	pkg, err := w.importFrom(fromPath, fromDir, mode)
	if err != nil {
		return nil, err
	}
	return pkg.Package, nil
}

func (w *Walker) import_(name string) (*apiPackage, error) {
	return w.importFrom(name, "", 0)
}

                                ? Source.fromPath(installationToolchainsFile)
                                : null)
                .userToolchainsSource(
                        userToolchainsFile != null && Files.isRegularFile(userToolchainsFile)
                                ? Source.fromPath(userToolchainsFile)
                                : null)
                .build();

                                ? Source.fromPath(installationSettingsFile)
                                : null)
                .projectSettingsSource(
                        projectSettingsFile != null && Files.exists(projectSettingsFile)
                                ? Source.fromPath(projectSettingsFile)
                                : null)
                .userSettingsSource(

    static ModelBuilderRequest build(@Nonnull Session session, @Nonnull Path path) {
        return builder()
                .session(nonNull(session, "session cannot be null"))
                .source(ModelSource.fromPath(path))
                .build();
    }

    @Nonnull
    static ModelBuilderRequestBuilder builder() {
        return new ModelBuilderRequestBuilder();
    }

    @Nonnull