/**
 * Used to build up an array of transform functions to operate on an array of data.
 */
export declare class DataPipeline {
    transformArray: any;
    constructor(transformArray?: any[]);
    /**
     * Add the provided transform function to the transformArray
     *  and assign that transform the provided key.
     * @param transform
     * @param key
     */
    addTransform(transform: any, key: string): DataPipeline;
    /**
     * Get the index in the transformArray of the transform with provided key.
     * @param key
     */
    getTransformIndex(key: string): number;
    /**
     * Check whether a transform with the provided key exists in the transformArray
     * @param transformationKey
     */
    hasTransformation(transformationKey: string): boolean;
    /**
     * Remove the transform, at the provided index, from transformArray.
     * @param removeIndex
     */
    removeTransformByIndex(removeIndex: number): DataPipeline;
    /**
     * Remove the transform, with the provided key, from the transformArray.
     * @param key
     */
    removeTransformByKey(key: string): DataPipeline;
    /**
     * Add an Aggregate Group transform to the transformArray.
     * @param groupKeyArray
     * @param valueKey
     * @param operation
     * @param key
     */
    addAggregateGroupTransform(groupKeyArray: string[], valueKey: any, operation: any, key?: string): DataPipeline;
    /**
     * Add a Categorize Nested transform to the transformArray.
     * @param key
     */
    addCategorizeNestedTransform(key?: string): DataPipeline;
    /**
     * Add a Convert transform to the transformArray.
     * @param conversionMap
     * @param key
     */
    addConvertTransform(conversionMap: any, key?: string): DataPipeline;
    /**
     * Add a Filter transform to the transformArray.
     * @param filter
     * @param key
     */
    addFilterTransform(filter: Function, key?: string): DataPipeline;
    /**
     * Add an Operation transform to the transformArray.
     * @param operation
     * @param key
     */
    addOperationTransform(operation: Function, key?: string): DataPipeline;
    /**
     * Add an Operate Each transform to the transformArray.
     * @param operation
     * @param key
     */
    addOperateEachTransform(operation: Function, key?: string): DataPipeline;
    /**
     * Add an Sort transform to the transformArray.
     * @param comparator
     * @param key
     */
    addSortTransform(comparator: Function, key?: string): DataPipeline;
    /**
     * Add an Sort By Value transform to the transformArray.
     * @param valueMap
     * @param asc
     * @param key
     */
    addSortByValueTransform(valueMap: Function, asc?: boolean, key?: string): DataPipeline;
    /**
     * Add an Sort By Attribute transform to the transformArray.
     * @param attribute
     * @param asc
     * @param ignoreCase
     * @param key
     */
    addSortByAttributeTransform(attribute: any, asc?: boolean, ignoreCase?: boolean, key?: string): DataPipeline;
    /**
     * Apply all transforms, in the transformArray, to each item in the dataArray.
     * @param dataArray
     * @param doCopy
     */
    transform(dataArray: any, doCopy?: boolean): any;
    /**
     * Apply all transforms to the dataArray and then return a Bin Data Model.
     *  Good for visualizing the data as a Histogram.
     * @param dataArray
     * @param valueMap
     * @param binWidth
     */
    transformBinModel(dataArray: any, valueMap: Function, binWidth: number): any;
    /**
     * Apply all transforms to the dataArray and then return a Box Data Model.
     *  Good for visualizing the data as a Box Plot.
     * @param dataArray
     * @param valueMap
     */
    transformBoxModel(dataArray: any, valueMap: Function): any;
    /**
     * Apply all transforms to the dataArray and then return a Pie Data Model.
     *  Good for visualizing the data as a Pie Chart.
     * @param dataArray
     * @param valueMap
     */
    transformPieModel(dataArray: any, valueMap: Function): any;
    /**
     * Apply all transforms to the dataArray and then return a Stack Data Model.
     *  Good for visualizing the data as a Stacked Bar Chart.
     * @param dataArray
     * @param mapper
     */
    transformStackModel(dataArray: any, mapper: Function): any;
    /**
     * Create a clone of this DataPipeline.
     */
    clone(): DataPipeline;
}
/**
 * Produces a DataPipeline with transforms based on the provided object.
 * @param transforms - object that contains transform directives for resulting DataPipeline
 *  transforms.order - a sort transform config
 *   transforms.order.method - the sort method (ASC, DESC)
 *   transforms.order.column - attribute to sort by
 *   transforms.order.ignoreCase - whether to be case insensitive when sorting column
 *  transforms.filters - contains a list of filter transform config
 *   transforms.filters.${filterName} - a filter transform config
 *   transforms.filters.${filterName}.type - the type of filter ("categorical", "range")
 *   transforms.filters.${filterName}.value - the value to filter by (used by categorical type filter)
 *   transforms.filters.${filterName}.minRange - filter out values less than this value (used by range type filter)
 *   transforms.filters.${filterName}.maxRange - filter out values greater than this value (used by range type filter)
 * @returns DataPipeline
 * @example
 *
 */
export declare function getTransformsDataPipeline(transforms: any): DataPipeline;