Aggregation Builder

/**
 * Factory class for creating matrix stats aggregation builders
 */
public class MatrixStatsAggregationBuilders {
    /**
     * Create a new MatrixStats aggregation with the given name
     * @param name The name for the aggregation
     * @return A new MatrixStatsAggregationBuilder instance
     */
    public static MatrixStatsAggregationBuilder matrixStats(String name);
}

import org.elasticsearch.search.aggregations.matrix.MatrixStatsAggregationBuilders;

// Create a matrix stats aggregation builder
MatrixStatsAggregationBuilder builder = MatrixStatsAggregationBuilders.matrixStats("sales_analysis");

/**
 * Builder for matrix stats aggregations
 */
public class MatrixStatsAggregationBuilder extends ArrayValuesSourceAggregationBuilder.LeafOnly<MatrixStatsAggregationBuilder> {
    /** The aggregation type name used in Elasticsearch queries */
    public static final String NAME = "matrix_stats";
    
    /**
     * Constructor for creating a new matrix stats aggregation builder
     * @param name The name for this aggregation instance
     */
    public MatrixStatsAggregationBuilder(String name);
    
    /**
     * Sets the multi-value mode for handling fields with multiple values
     * @param multiValueMode The mode to use (AVG, SUM, MIN, MAX, MEDIAN)
     * @return This builder instance for method chaining
     */
    public MatrixStatsAggregationBuilder multiValueMode(MultiValueMode multiValueMode);
    
    /**
     * Gets the current multi-value mode
     * @return The configured MultiValueMode
     */
    public MultiValueMode multiValueMode();
    
    /**
     * Returns the aggregation type name
     * @return "matrix_stats"
     */
    public String getType();
}

import org.elasticsearch.search.aggregations.matrix.MatrixStatsAggregationBuilders;
import org.elasticsearch.search.MultiValueMode;
import java.util.Arrays;

// Basic usage with default settings
MatrixStatsAggregationBuilder basicBuilder = MatrixStatsAggregationBuilders
    .matrixStats("product_stats")
    .fields(Arrays.asList("price", "weight", "rating"));

// Advanced usage with multi-value mode configuration
MatrixStatsAggregationBuilder advancedBuilder = MatrixStatsAggregationBuilders
    .matrixStats("detailed_analysis")
    .fields(Arrays.asList("sales", "profit", "customers"))
    .multiValueMode(MultiValueMode.AVG)
    .format("0.00");

// With missing value handling
Map<String, Object> missingValues = new HashMap<>();
missingValues.put("sales", 0.0);
missingValues.put("profit", 0.0);

MatrixStatsAggregationBuilder builderWithMissing = MatrixStatsAggregationBuilders
    .matrixStats("complete_analysis")
    .fields(Arrays.asList("sales", "profit", "customers"))
    .missingMap(missingValues);

/**
 * Base class for aggregations working with arrays of values sources
 */
public abstract class ArrayValuesSourceAggregationBuilder<AB extends ArrayValuesSourceAggregationBuilder<AB>> 
    extends AbstractAggregationBuilder<AB> {
    
    /**
     * Sets the fields to use for this aggregation
     * @param fields List of field names to analyze
     * @return This builder instance for method chaining
     */
    public AB fields(List<String> fields);
    
    /**
     * Gets the currently configured fields
     * @return List of field names
     */
    public List<String> fields();
    
    /**
     * Sets the format to use for the output of the aggregation
     * @param format Format string for numeric output
     * @return This builder instance for method chaining
     */
    public AB format(String format);
    
    /**
     * Gets the format to use for the output of the aggregation
     * @return Current format string
     */
    public String format();
    
    /**
     * Sets the value to use when the aggregation finds a missing value in a document
     * @param missingMap Map of field names to default values
     * @return This builder instance for method chaining
     */
    public AB missingMap(Map<String, Object> missingMap);
    
    /**
     * Gets the value to use when the aggregation finds a missing value in a document
     * @return Map of field names to default values
     */
    public Map<String, Object> missingMap();
}

/**
 * Base class for leaf-only aggregations (cannot accept sub-aggregations)
 */
public abstract static class LeafOnly<AB extends ArrayValuesSourceAggregationBuilder<AB>> 
    extends ArrayValuesSourceAggregationBuilder<AB> {
    
    /**
     * Constructor for leaf-only aggregation builders
     * @param name The aggregation name  
     */
    protected LeafOnly(String name);
    
    /**
     * Returns the bucket cardinality for this aggregation type
     * @return BucketCardinality.NONE (leaf aggregations don't create buckets)
     */
    public final BucketCardinality bucketCardinality();
}