ForkedProjectSucceeded,
        ForkedProjectFailed,
    }

    /**
     * Gets the type of the event.
     *
     * @return The type of the event, never {@code null}.
     */
    Type getType();

    /**
     * Gets the session from which this event originates.
     *
     * @return The current session, never {@code null}.
     */
    MavenSession getSession();

    /**

        }
        return result;
    }

    public static Map<String, String> beanToMap(final Artifact artifact) {
        final Map<String, String> item = new HashMap<>();
        item.put("type", artifact.getType().getId());
        item.put("id", artifact.getName() + ":" + artifact.getVersion());
        item.put("name", artifact.getName());
        item.put("version", artifact.getVersion());

    String getGroupId();

    String getArtifactId();

    String getVersion();

    void setVersion(String version);

    String getScope();

    String getType();

    String getClassifier();

    boolean hasClassifier();

    File getFile();

    void setFile(File destination);

    String getBaseVersion();

    void setBaseVersion(String baseVersion);

                    message,
                    "  ",
                    artifact.getGroupId(),
                    artifact.getArtifactId(),
                    artifact.getVersion(),
                    artifact.getType(),
                    artifact.getClassifier(),
                    artifact.getDownloadUrl(),
                    artifact.getDependencyTrail()));
        }

        buffer.append("----------").append(LS);

    }

    @Override
    public void onEvent(Object event) {
        if (event instanceof ExecutionEvent) {
            ExecutionEvent executionEvent = (ExecutionEvent) event;
            if (executionEvent.getType() == ExecutionEvent.Type.SessionEnded) {
                usedTypes.clear();
            }
        }
    }

    @Override
    public Optional<Type> lookup(String id) {
        return Optional.of(require(id));

            bufferStream.readFully(this.checksum);
        }
        catch ( IOException e ) {
            throw new PACDecodingException("Malformed PAC signature", e);
        }
    }


    public int getType () {
        return this.type;
    }


    public byte[] getChecksum () {
        return this.checksum;
    }

  private static Type getSupertype(Type type, Class<?> superclass) {
    Class rawType = superclass;
    return TypeToken.of(type).getSupertype(rawType).getType();
  }

  private static Type getSubtype(Type type, Class<?> subclass) {
    return TypeToken.of(type).getSubtype(subclass).getType();
  }

        ArtifactType stereotype = stereotypes.get(dependency.getType());
        if (stereotype == null) {
            // TODO: this here is fishy
            stereotype = new DefaultType(dependency.getType(), Language.NONE, "", null, false);
        }

        boolean system = dependency.getSystemPath() != null

                dependency.getArtifactId(),
                dependency.getVersion(),
                dependency.getScope(),
                dependency.getType(),
                dependency.getClassifier(),
                new TestArtifactHandler(dependency.getType()));

        if (Artifact.SCOPE_SYSTEM.equals(dependency.getScope())) {
            artifact.setFile(new File(dependency.getSystemPath()));

                .version(dependency.getVersion().asString())
                .classifier(dependency.getClassifier())
                .extension(dependency.getExtension())
                .type(dependency.getType().id())
                .scope(dependency.getScope().id())
                .optional(dependency.isOptional())
                .build();
    }

    @Nonnull