* Implementation may override with absolute path instead.
     */
    default Path directory() {
        Path src = Path.of("src");
        return module().map(src::resolve)
                .orElse(src)
                .resolve(scope().id())
                .resolve(language().id());
    }

    /**
     * {@return the list of patterns for the files to include}
     * The path separator is {@code /} on all platforms, including Windows.

                break;
            }
            trace = trace.getParent();
        }
        return collectStepTrace;
    }

    /**
     * The event "artifact resolved" if fired WHENEVER an artifact is resolved, BUT it happens also when an artifact
     * descriptor (model, the POM) is being built, and parent (and parent of parent...) is being asked for. Hence, this

    public Path get() {
        return directory;
    }

    /**
     * Resolves against current cwd, resulting path is normalized.
     *
     * @throws NullPointerException if {@code seg} is {@code null}.
     */
    @Nonnull
    public Path resolve(String seg) {
        requireNonNull(seg, "seg");
        return directory.resolve(seg).normalize();
    }

    /**

    /**
     * Resolve part of an array of SIDs using a cache and at most one MSRPC request.
     *
     * @param tc the CIFS context to use
     * @param authorityServerName the server to use for SID resolution
     * @param sids the array of SIDs to resolve
     * @param off the starting offset in the array
     * @param len the number of SIDs to resolve

import org.apache.maven.model.Plugin;

/**
 * Exception occurring trying to resolve a plugin.
 *
 */
public class PluginResolutionException extends Exception {

    private final Plugin plugin;

    public PluginResolutionException(Plugin plugin, Throwable cause) {
        super(
                "Plugin " + plugin.getId() + " or one of its dependencies could not be resolved: " + cause.getMessage(),
                cause);

/**
 * A request to resolve the dependencies of a project.
 *
 * @deprecated use {@code org.apache.maven.api.services.ProjectBuilder} instead
 */
@Deprecated(since = "4.0.0")
public interface DependencyResolutionRequest {

    /**
     * Gets the project to resolve dependencies for.
     *
     * @return The project to resolve dependencies for or {@code null} if not set.
     */

    /**
     * Sets whether to resolve this request path in DFS.
     *
     * @param resolve true to enable DFS resolution
     */
    void setResolveInDfs(boolean resolve);

    /**
     * Checks if this request should be resolved in DFS.
     *
     * @return whether to resolve the request path in DFS
     */
    boolean isResolveInDfs();

            return new File[0];
        }
        return libDir.listFiles(filter);
    }

    /**
     * Resolves system properties in a given string.
     * @param value The string to resolve.
     * @return The resolved string.
     */
    public static String resolve(final String value) {
        if (value == null) {
            return null;
        }

        }
        return toString();
    }

    /**
     * Manually resolve this SID. Normally SIDs are automatically
     * resolved. However, if a SID is constructed explicitly using a SID
     * constructor, JCIFS will have no knowledge of the server that created the
     * SID and therefore cannot possibly resolve it automatically. In this case,
     * this method will be necessary.
     *

`config.json` and bucket DNS SRV records. `MINIO_DOMAIN` indicates the domain suffix for the bucket which
will be used to resolve bucket through DNS. For example if you have a bucket such as `mybucket`, the
client can use now `mybucket.domain.com` to directly resolve itself to the right cluster. `MINIO_PUBLIC_IPS`
points to the public IP address where each cluster might be accessible, this is unique for each cluster.