public interface StageConfigurer {

  ...

/**
 * get the stage name.
 * @return stage name
 */
String getStageName();

/**
 * add validation errorsfailures.
 * @param e errorsfailures
 */
void addValidationErroraddValidationFailure(ValidationErrorValidationFailure e);

/**
 * Represents errorfailure that occurred during validation.
 */
@Beta
public class ValidationErrorValidationFailure {
  private final String message;
  private final String type;
  private /**final Map<String, Object> properties;
*
Creates an error with provided error message.
   * @param message error message
   */
  public ValidationError(String message) {ValidationFailure(String message, String type, Map<String, Object> map) {
    this.message = message;
     this.messagetype = messagetype;
    this.typeproperties = getType()map;
  }

  /**public static ValidationFailureBuilder builder() {
    *return Returns the type of the error.
   */
  public String getType()new DefaultValidationFailureBuilder();
  }
}

@Override
public void configurePipeline(PipelineConfigurer pipelineConfigurer) {
  pipelineConfigurer.createDataset(conf.destinationFileset, FileSet.class);
  StageConfigurer stageConfigurer = pipelineConfigurer.getStageConfigurer();
  // get the name of the stage 
  String stageName = stageConfigurer.getStageName();
  try {
    Pattern.compile(conf.filterRegex);
  } catch (Exception e) {  
    // add validation error to stage configurer
    ValidationBuilder
    stageConfigurer.addValidationError(new InvalidStagePropertyErroraddValidationFailure(ValidationFailures.createFieldValidationFailure(e.getMessage(), stageName, "filterRegex"));
  }
  if (conf.sourceFileset.equals(conf.destinationFileset)) {
    // add validation error to stage configurer
    stageConfigurer.addValidationError(new InvalidStageErroraddValidationFailure(ValidationFailures.createStageValidationFailure("source and destination filesets must be different", stageName));
  }
}

/**
 * Represents error that occurred during validation.
 */
@Beta
public class ValidationError {
  private final String message;
  protected final List<Map<String, Object>> causes;

  /**
   * Creates a validation error with a message and empty map of causes
   * @param message
   */
  public ValidationError(String message) {
    this.message = message;	
    this.causes = new ArrayList<>();
  }
 
  @Override
   public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    ValidationError that = (ValidationError) o;
    return message.equals(that.message) && causes.equals(that.causes);
  }

  @Override
  public int hashCode() {
    return Objects.hash(message, causes);
  }
  
}

/**
 * Cause attributes.
 */
public enum CauseAttributes {
  STAGE("stage"), // represents stage being validated
  PROPERTY("property"), // represents stage property
  INPUT_FIELD("input_field") // represents field in the input schema
  OUTPUT_FIELD("output_field") // represents field in the output schema
  OUTPUT_PORT("output_port"), // represents output port for plugins such as SplitterTransform where multiple output schemas are expected
  INPUT_STAGE("input_stage"), // represents input stage for plugins such as Joiner where multiple input schemas are expected
  ..

  private String name;

  ErrorAttributes(String name) {
    this.name = name;
  }
}

/**
 * Represents error that occurred during stage validation.
 */
@Beta
public class InvalidStageError extends ValidationError {
  /**
   * Creates validation error that occurred during stage validation.
   * @param message error message
   * @param stage name of the stage that caused this validation error
   */
  public InvalidStageError(String message, String stage) {
    super(message);
    causes.add(Collections.singletonMap("stage", stage));
  }
}

/**
 * Represents error that occurred during stage config property validation.
 */
@Beta
public class InvalidStagePropertyError extends ValidationError {
 /**
   * Creates validation error that occurred during stage validation.
   * @param message error message
   * @param stage name of the stage that caused this validation error
   * @param property property that is invalid
   */
  public InvalidStageError(String message, String stage, String property) {
    super(message);
    Map<String, Object> map = new HashMap<>();
    map.put("stage", stage);
    map.put("property", property);
    causes.add(map);
  }


 /**
   * Creates validation error that occurred during stage validation.
   * @param message error message
   * @param stage name of the stage that caused this validation error
   * @param properties properties that is caused this error
   */
  public InvalidStageError(String message, String stage, String[] properties) {
    super(message);
    Map<String, Object> map = new HashMap<>();
    for (String property : properties) {
        map.put("stage", stage);
        map.put("property", property);
    }
    causes.add(map);
  }
}

/**
 * Represents invalid input schema error. 
 */
public class InvalidInputSchemaError extends NewValidationError {

  /**
   * Creates invalid input schema error.
   * @param message error message
   * @param stage name of the stage 
   * @param map map of incoming stage name to field that is invalid.
   */
  public InvalidInputSchemaError(String message, String stage, Map<String, String> map) {
    super(message);
    for (Map.Entry<String, String> entry : map.entrySet()) {
      Map<String, Object> causeMap = new HashMap<>();
      causeMap.put("stage", stage);
      causeMap.put("input_stage", entry.getKey());
      causeMap.put("input_field", entry.getValue());
      causes.add(causeMap);
    }
  }
}

/**
 * Represents invalid output schema error.
 */
public class InvalidOutputSchemaError extends NewValidationError {

  /**
   * Creates invalid output schema error.
   * @param message error message
   * @param stage name of the stage
   * @param map map of output going port name to field that is invalid
   */
  public InvalidOutputSchemaError(String message, String stage, Map<String, String> map) {
    super(message);
    for (Map.Entry<String, String> entry : map.entrySet()) {
      Map<String, Object> causeMap = new HashMap<>();
      causeMap.put("stage", stage);
      causeMap.put("output_port", entry.getKey());
      causeMap.put("output_field", entry.getValue());
      causes.add(causeMap);
    }
  }
}

@Override
public void configurePipeline(PipelineConfigurer pipelineConfigurer) {
  pipelineConfigurer.createDataset(conf.destinationFileset, FileSet.class);
  StageConfigurer stageConfigurer = pipelineConfigurer.getStageConfigurer();
  // get the name of the stage 
  String stageName = stageConfigurer.getStageName();
  try {
    Pattern.compile(conf.filterRegex);
  } catch (Exception e) {  
    // add validation error to stage configurer
    stageConfigurer.addValidationError(new InvalidStagePropertyError(e.getMessage(), stageName, "filterRegex"));
  }
  if (conf.sourceFileset.equals(conf.destinationFileset)) {
    // add validation error to stage configurer
    stageConfigurer.addValidationError(new InvalidStageError("source and destination filesets must be different", stageName));
  }
}