*/
    @Nonnull
    Version getBaseVersion();

    /**
     * Returns the classifier of the artifact.
     *
     * @return the classifier or an empty string if none, never {@code null}
     * @see ArtifactCoordinates#getClassifier()
     */
    @Nonnull
    String getClassifier();

    /**

class TransformedArtifactHandler implements ArtifactHandler {

    private final String classifier;

    private final String extension;

    private final String packaging;

    TransformedArtifactHandler(String classifier, String extension, String packaging) {
        this.classifier = classifier;
        this.extension = requireNonNull(extension);
        this.packaging = requireNonNull(packaging);
    }

            String artifactId,
            String version,
            String type,
            String classifier,
            List<ArtifactRepository> remoteRepositories,
            List<String> path,
            Throwable t) {
        super(message, groupId, artifactId, version, type, classifier, remoteRepositories, path, t);
    }

    public ArtifactResolutionException(
            String message,

     *
     * @return the file extension
     */
    String getExtension();

    String getDirectory();

    /**
     * Returns the default classifier used if a different one is not set in pom.xml.
     *
     * @return the classifier
     */
    String getClassifier();

    String getPackaging();

    boolean isIncludesDependencies();

    String getLanguage();

    /**

    private final String extension;
    private final String classifier;
    private final boolean includesDependencies;
    private final Set<PathType> pathTypes;
    private final Map<String, String> properties;

    public DefaultType(
            String id,
            Language language,
            String extension,
            String classifier,
            boolean includesDependencies,

        assertEquals(
                "jar", depArtifact.getProperty("type", null)); // shouldn't it be java-sources given the classifier?
        assertEquals(
                "true",
                depArtifact.getProperty("constitutesBuildPath", null)); // shouldn't it be false given the classifier?
        assertEquals("false", depArtifact.getProperty("includesDependencies", null));

                        && srcInfo.repository != dstInfo.repository)) {
            infos.put(dstKey, srcInfo);
        }
    }

    private String getKey(String classifier, String extension) {
        return (classifier == null ? "" : classifier.trim()) + ':' + (extension == null ? "" : extension.trim());
    }

    private ArtifactRepository getRepository(

            String classifier,
            String extension) {
        super(
                source.getGroupId(),
                source.getArtifactId(),
                source.getVersionRange(),
                source.getScope(),
                extension,
                classifier,
                new TransformedArtifactHandler(

      <fields>
        <field>
          <name>classifier</name>
          <version>1.1.0+</version>
          <type>String</type>
          <description>The classifier of the sub-artifact. Each classifier and extension pair may only appear once.</description>
          <defaultValue></defaultValue>
          <identifier>true</identifier>

     * @param artifactId the artifact identifier, or {@code null} is unspecified
     * @param version the artifact version, or {@code null} is unspecified
     * @param classifier the artifact classifier, or {@code null} is unspecified
     * @param extension the artifact extension, or {@code null} is unspecified
     * @param type the artifact type, or {@code null} is unspecified