* This is the default behavior.
         */
        RELEASE_OR_SNAPSHOT
    }

    /**
     * Gets the artifact coordinates whose version range should be resolved.
     * The coordinates may contain a version range (e.g., "[1.0,2.0)") or a single version.
     *
     * @return the artifact coordinates, never {@code null}
     */
    @Nonnull

                sanitized.append(component);
            }

            final Path resolved = Paths.get(exportPath, sanitized.toString()).normalize();
            final Path baseDir = Paths.get(exportPath).normalize();
            if (!resolved.startsWith(baseDir)) {
                logger.warn("Path traversal detected: url={}, resolved={}", url, resolved);

        if (!artifact.isRelease() && buildReactor != null) {
            artifact = buildReactor.find(artifact);
        }

        if (!artifact.isResolved() && ideWorkspace != null) {
            artifact = ideWorkspace.find(artifact);
        }

        if (!artifact.isResolved()) {
            artifact = userLocalArtifactRepository.find(artifact);
        }

        return artifact;
    }

    @Override

     * the analygous {@link jcifs.smb1.UniAddress} or {@link java.net.InetAddress}
     * <code>getByName</code> methods can be used for that.
     *
     * @param host hostname to resolve
     * @return the resolved NetBIOS address
     * @throws java.net.UnknownHostException if there is an error resolving the name
     */

    public static NbtAddress getByName(final String host) throws UnknownHostException {

    std::string& summary) const {
  absl::Status status;
  AbstractTensorPtr resolved(
      // TODO(allenl): Resolve should be const, and the caches that get updated
      // marked mutable.
      const_cast<ImmediateExecutionTensorHandle*>(this)->Resolve(&status));
  if (!status.ok()) {
    return status;
  }
  summary = resolved->SummarizeValue();
  return absl::OkStatus();
}

     * platform-specific file separator if a base directory is given. Otherwise, the input path will be returned
     * unaltered.
     *
     * @param path The path to resolve, may be {@code null}.
     * @param basedir The base directory to resolve relative paths against, may be {@code null}.

     * @throws SmbException if an SMB error occurs
     * @throws MalformedURLException if the URL is not properly formatted
     * @throws UnknownHostException if the host cannot be resolved
     */

    public SmbFileOutputStream(final String url) throws SmbException, MalformedURLException, UnknownHostException {
        this(url, false);
    }

    /**

                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

     * @param queryLogReader The query log reader
     * @param docPerReq The number of documents to process per request
     * @param requestInterval The interval between requests
     * @return A Promise that will be resolved with the SuggestIndexResponse
     */
    public Deferred<SuggestIndexResponse>.Promise indexFromQueryLog(final ContentIndexingContext ctx, final QueryLogReader queryLogReader,

     *
     * @return resolveHashes
     */
    boolean isResolveHashes();

    /**
     * Check if this referral needs to be resolved further
     *
     * @return whether this refrral needs to be resolved further
     */
    boolean isIntermediate();

    /**
     * Combine this referral with another to form a chain
     *
     * @param next the referral to combine with