*
     * @param hostname the hostname to resolve
     * @param possibleNTDomainOrWorkgroup if true, perform additional master browser lookup
     *
     * @return the first resolved address
     * @throws UnknownHostException if the hostname cannot be resolved
     */
    Address getByName(String hostname, boolean possibleNTDomainOrWorkgroup) throws UnknownHostException;

     *             parameter {@code coordinates} is {@code null} or invalid
     */
    default ArtifactResolverResult resolve(Session session, Collection<? extends ArtifactCoordinates> coordinates) {
        return resolve(ArtifactResolverRequest.build(session, coordinates));
    }

    /**
     * Resolves several artifacts from their coordinates.
     *
     * @param session {@link Session}

            }
        }
        return null;
    }

    /**
     * Resolves a DFS path to obtain referral information
     * @param domain the domain name
     * @param root the DFS root
     * @param path the path to resolve
     * @param auth the authentication credentials
     * @return a DFS referral for the resolved path
     * @throws SmbAuthException if authentication fails
     */

        }
        return resolve(request);
    }

    @Nonnull
    default DependencyResolverResult resolve(@Nonnull Session session, @Nonnull Project project) {
        return resolve(
                DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.RESOLVE, project));
    }

    @Nonnull
    default DependencyResolverResult resolve(

    default VersionRangeResolverResult resolve(
            @Nonnull Session session, @Nonnull ArtifactCoordinates artifactCoordinates)
            throws VersionResolverException {
        return resolve(VersionRangeResolverRequest.build(session, artifactCoordinates));
    }

    /**
     * Expands a version range to a list of matching versions, in ascending order.
     * For example, resolves "[3.8,4.0)" to "3.8", "3.8.1", "3.8.2".

            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;
        }

    /**
     * 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();

     * 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 {

    /**
     * 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

        }
        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.
     *