@PublicEvolving
interface Stage<T extends Stage<T>> extends WithParams<T>, Serializable {
    

@PublicEvolving
interface Stage<T extends Stage<T>> extends WithParams<T>, Serializable {
    /**
     * This method checks the compatibility between input schemas, stage's parameters and stage's
     * logic. It should raise an exception if there is any mismatch, e.g. the number of input
     * schemas is wrong, or if a required field is missing from a schema.
     *
     * <p>If there is no mismatch, the method derives and returns the output schemas from the input
     * schemas.
     *
     * <p>Note that the output schemas of a given Estimator instance should equal the output schemas
     * of the Transformer instance fitted by this Estimator instance, suppose the same list of input
     * schemas are used as inputs to the fit/transform methods respectively.
     *
     * @param schemas the list of schemas of the input tables.
     * @return the list of schemas of the output tables.
     */
    TableSchema[] transformSchemas(TableSchema... schemas);

    /** Skipped */
    default String toJson() {...}

    /** Skipped */
    default void loadJson(String json) {...}
}

@PublicEvolving
public interface Transformer<T extends Transformer<T>> extends Stage<T> {

    /**
     * AppliesThis themethod Transformerchecks onthe thecompatibility givenbetween input tablesschemas, andstage's returnsparameters the result tables.and stage's
     *
     * @param inputs a list of tables logic. It should raise an exception if there is any mismatch, e.g. the number of input
     * @return schemas is wrong, or if a list of tablesrequired field is missing from a schema.
     */
    Table[] transform(Table... inputs);

    /**
     * Uses the given list of tables to update internal states. This can be useful for e.g. online * <p>If there is no mismatch, the method derives and returns the output schemas from the input
     * schemas.
     *
     * learning<p>Note wherethat anthe Estimatoroutput fitsschemas anof infinitea streamgiven ofEstimator traininginstance samplesshould andequal streamsthe theoutput modelschemas
     * diff data to thisof the Transformer.
 instance fitted by this *
Estimator instance, suppose the same *list <p>Thisof methodinput
 may be called at most* once.
schemas are used as inputs to the fit/transform methods respectively.
     *
     * @param inputsschemas athe list of schemas of the input tables.
     */
 @return the list defaultof schemas void setStateStreams(Table... inputs) {of the output tables.
     */
   throw newTableSchema[] UnsupportedOperationException("this method is not implemented"transformSchemas(TableSchema... schemas);
    }

    /**
 Skipped    */
 Gets a list ofdefault tablesString representing changes of internal states of this Transformer. ThesetoJson() {...}

    /** Skipped */
    default *void tables might come from the Estimator that instantiated this Transformer.loadJson(String json) {...}
}

@PublicEvolving
public interface Transformer<T extends Transformer<T>> extends Stage<T> {

     /**
     * @return a list of tables
     */ Applies the Transformer on the given input tables, and returns the result tables.
    default Table[] getStateStreams() { *
     * @param  throw new UnsupportedOperationException("this method is not implemented");
    }
}

@PublicEvolving
public interface Estimator<E extends Estimator<E, M>, M extends Transformer<M>> extends Stage<E> {inputs a list of tables
     * @return a list of tables
     */
    Table[] transform(Table... inputs);

    /**
     * Trains onUses the given inputs and produces a Transformer. If this Estimator may be used tolist of tables to update internal states. This can be useful for e.g. online
     * composelearning awhere Pipeline,an theEstimator transformfits methodan ofinfinite thestream returnedof Transformertraining shouldsamples beand ablestreams tothe acceptmodel
     * adiff listdata ofto tablesthis of the same length and schemas as the fit method of this EstimatorTransformer.
     *
     * <p>This method may be called at most once.
     *
     * @param inputs a list of tables
     * @return a Transformer/
    default */
    M fitvoid setStateStreams(Table... inputs);
}

@PublicEvolving
public final class Pipeline implements Estimator<Pipeline, PipelineModel> {

    public Pipeline(List<Stage<?>> stages) {...}

    @Override
    public PipelineModel fit(Table... inputs) {... {
        throw new UnsupportedOperationException("this method is not implemented");
    }

    /**
  Skipped a few methods,* includingGets thea implementationslist of thetables Estimatorrepresenting APIs. */
}

@PublicEvolving
public final class PipelineModel implements Transformer<PipelineModel> {

changes of internal states of this Transformer. These
    public PipelineModel(List<Transformer<?>> transformers) {...}

    /** Skipped a few methods, including the implementations of the Transformer APIs. */
}

/**
 * A Graph acts as an Estimator. It consists of a DAG of stages, each of which is either an
 * Estimator or Transformer.
 */
@PublicEvolving
public final class Graph implements Estimator<Graph, GraphModel> {associated with this GraphBuilder. It can be used to specify the passing of
     * tables between stages, as well as the input/output tables of the Graph/GraphModel generated
     * by this builder.
     */
    public TableId createTableId(Graph(...) {...}

    /**@Override
    public * The Graph::fit and GraphModel::transform should invoke the fit/transform of the correspondingGraphModel fit(Table... inputs) {...}

    @Override
    public TableSchema[] transformSchemas(TableSchema... schemas) {
     * stage with the corresponding inputs.return schemas;
     *}

     /** <p>ReturnsSkipped a listfew of TableIdsmethods, whichincluding representsthe outputsimplementations of some the Transformer::transform
     * invocation.
     */
    public TableId[] getOutputs(Stage<?> stage, TableId... inputs) {...}
Estimator APIs. */
}

/** A GraphModel acts as a Transformer. It consists of a DAG of Transformers. */
@PublicEvolving
public final class GraphModel implements Transformer<GraphModel> {
    /**
 Skipped a few methods, *including The GraphModel::setStateStreams should invoke the setStateStreams of the corresponding stage
     * with the corresponding inputs.
     */the implementations of the Transformer APIs. */
}

/** A GraphBuilder helps connect Stage instances into a Graph or GraphModel. */
@PublicEvolving
public final class GraphBuilder {
    /**
    void setStateStreams(Stage<?> stage, TableId... inputs) {...}

    /**
     * The GraphModel::getStateStreams should invoke the getStateStreams of the corresponding stage.* Specifies the upper bound (could be loose) of the number of output tables that can be
     *
 returned by the  * <p>Returns a list of TableIds, which represents outputs of the getStateStreams invocationTransformer::getStateStreams and Transformer::transform methods, for any
     * stage involved in this Graph.
     */
    TableId[] getStateStreams(Stage<?> stage) {...}

    /** * <p>The default upper bound is 20.
     */
 Returns a Graph instancepublic whichGraphBuilder the following API specification: - Graph::fit should takesetMaxOutputLength(int maxOutputLength) {...}

    /**
     * inputsCreates anda returnsTableId aassociated GraphModel with thethis following specificationGraphBuilder. - GraphModel::transform
     * should take inputs and returns outputs. - GraphModel::setStateStreams should take
     * inputStates. - GraphModel::getStateStreams should return outputStates.
     *It can be used to specify the passing of
     * tables between stages, as well as the input/output tables of the Graph/GraphModel generated
     * by this builder.
     * <p>The fit/transform/setStateStreams/getStateStreams should invoke the APIs of the internal/
    public TableId createTableId() {...}

    /**
     * stages in the order specified by the DAG of stages.The Graph::fit and GraphModel::transform should invoke the fit/transform of the corresponding
     */
 stage with the Graph build(]corresponding inputs,.
 TableId[] outputs, TableId[] inputStates, TableId[] outputStates) {...}

 *
    /**
     * Returns<p>Returns a GraphModel instancelist of TableIds, which therepresents followingoutputs APIof specification: - GraphModelthe Transformer::transform
     * shouldinvocation.
 take inputs and returns outputs. - GraphModel::setStateStreams should take */
    public * inputStates. - GraphModel::getStateStreams should return outputStates.TableId[] getOutputs(Stage<?> stage, TableId... inputs) {...}

     /**
     * <p>The transform/setStateStreams/getStateStreamsThe GraphModel::setStateStreams should invoke the APIssetStateStreams of the corresponding internalstage
     * stages inwith the order specified by the DAG of stagescorresponding inputs.
     */
    void setStateStreams(Stage<?> stage, TableId... inputs) {...}

    /**
   <p>This method throws* exception if any stage of this graph is an EstimatorThe GraphModel::getStateStreams should invoke the getStateStreams of the corresponding stage.
     */
    GraphModel buildModel(TableId[] inputs, TableId[] outputs, TableId[] inputStates,* <p>Returns a list of TableIds, which represents outputs of the getStateStreams invocation.
     */
    TableId[] outputStatesgetStateStreams(Stage<?> stage) {...}

    //**
 The TableId is necessary to* passReturns thea inputs/outputsGraph of variousinstance which the following API calls across the specification: - Graph::fit should take
    // Graph/GraphModel stags.
    static class TableId {}

}