import { TLabelProviderDefinition } from "../../../Builder/buildAxis";
import { NumberRange } from "../../../Core/NumberRange";
import { PropertyChangedEventArgs } from "../../../Core/PropertyChangedEventArgs";
import { ESeriesType } from "../../../types/SeriesType";
import { TSciChart } from "../../../types/TSciChart";
import { IPointSeries } from "../../Model/PointSeries/IPointSeries";
import { UniformHeatmapDataSeries } from "../../Model/UniformHeatmapDataSeries";
import { ResamplingParams } from "../../Numerics/Resamplers/ResamplingParams";
import { LabelProviderBase2D } from "../Axis/LabelProvider/LabelProviderBase2D";
import { BaseRenderableSeries } from "./BaseRenderableSeries";
import { IContoursDataLabelProviderOptions } from "./DataLabels/ContoursDataLabelProvider";
import { HeatmapColorMap, IHeatmapColorMapOptions } from "./HeatmapColorMap";
import { IHitTestProvider } from "./HitTest/IHitTestProvider";
import { IBaseRenderableSeriesOptions } from "./IBaseRenderableSeriesOptions";
/**
 * Optional parameters passed to {@link UniformContoursRenderableSeries} constructor
 */
export interface IContoursRenderableSeriesOptions extends IBaseRenderableSeriesOptions {
    /**
     * The {@link HeatmapColorMap} instance, which maps heatmap z-values to colors
     * or an {@link IHeatmapColorMapOptions} object which will be used to build a HeatmapColorMap
     */
    colorMap?: HeatmapColorMap | IHeatmapColorMapOptions;
    /**
     * The {@link UniformHeatmapDataSeries} instance containing 2-dimensional heatmap data
     */
    dataSeries?: UniformHeatmapDataSeries;
    /**
     * The minimum Z value for which contours will be drawn.  Defaults to the data z minimum.
     */
    zMin?: number;
    /**
     * The maximum Z value for which contours will be drawn.  Defaults to the data z maximum.
     */
    zMax?: number;
    /**
     * The step on Z, used to calculate spacing between contours.
     * The first contour draws at minimum Z value if no zOffset is provided
     */
    zStep?: number;
    /**
     * The offset of the first contour, can take positive or negative values.
     * In order to start contours from a value other than minimum Z provide a value,
     * the contours will start from (minimum Z + zOffset)
     */
    zOffset?: number;
    /**
     * Explicit list of Z values at which to draw contour lines.
     * When set and non-empty, takes precedence over zMin/zMax/zStep/zOffset and exactly one
     * contour is drawn per provided level. Levels outside the data Z range are ignored.
     */
    zLevels?: number[];
    /**
     * The major line style
     */
    majorLineStyle?: TContourLineStyle;
    /**
     * The minor line style
     */
    minorLineStyle?: TContourLineStyle;
    /**
     * The number of minors per major
     */
    minorsPerMajor?: number;
    /**
     * Options to pass to the {@link DataLabelProvider}. Set a style with font and size to enable per-point text for this series.
     */
    dataLabels?: IContoursDataLabelProviderOptions;
    /** A labelProvider which is called to format zValues when using a cursor modifier */
    zLabelProvider?: LabelProviderBase2D | TLabelProviderDefinition;
}
export interface IContourDrawingParams {
    xMin: number;
    xMax: number;
    yMin: number;
    yMax: number;
    zMin: number;
    zMax: number;
    zOffset: number;
    majorStepZ: number;
    minorStepZ: number;
    majorLineStyle: TContourLineStyle;
    minorLineStyle: TContourLineStyle;
    dataZRange: NumberRange;
    /** Explicit Z levels (filtered to those inside dataZRange). Empty/undefined when in periodic mode. */
    zLevels?: number[];
}
/**
 * A type class to contain information about contour line styles
 * @remarks
 * A contour line is drawn using the {@link UniformContoursRenderableSeries} with a 2D array of data
 * - Set the color as an HTML Color code to define the color
 * - Set the strokeThickness to change the thickness of the contour line
 */
export declare type TContourLineStyle = {
    strokeThickness?: number;
    color?: string;
};
/** @ignore */
export declare const COLOR_MAP_PREFIX = "colorMap.";
export declare enum EContourColorMapMode {
    /**
     *  Applies the Gradient Colors from {@link UniformContoursRenderableSeries} ColorMap individually,
     *  ignoring offsets, e.g. with Gradient Stops Red, Green, Blue then
     *  contour lines will appear Red Green or Blue
     */
    AlternateColors = "AlternateColors",
    /**
     * Applies the Gradient Colors from {@link UniformContoursRenderableSeries} ColorMap according to the data on the chart
     */
    GradientColors = "GradientColors"
}
/**
 * Defines a JavaScript Uniform Contours series or Contour Lines chart type in SciChart's High Performance Real-time
 * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
 *
 * ---
 * 📚 Docs: {@link https://www.scichart.com/documentation/js/v4/2d-charts/chart-types/uniform-contours-renderable-series/}
 */
export declare class UniformContoursRenderableSeries extends BaseRenderableSeries {
    static readonly DEFAULT_CONTOURS_COUNT: number;
    static readonly DEFAULT_MAJOR_LINE_STYLE: TContourLineStyle;
    static readonly DEFAULT_MINOR_LINE_STYLE: TContourLineStyle;
    readonly type: ESeriesType;
    private colorMapProperty;
    private zMinProperty;
    private zMaxProperty;
    private zStepProperty;
    private xOffsetProperty;
    private zLevelsProperty;
    private colorMapModeProperty;
    private majorLineStyleProperty;
    private minorLineStyleProperty;
    private minorsPerMajorProperty;
    private zLabelProviderProperty;
    /**
     * Creates an instance of the {@link UniformHeatmapRenderableSeries}
     * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
     * native methods and access to our WebGL2 WebAssembly Drawing Engine
     * @param options optional parameters of type {@link IHeatmapRenderableSeriesOptions} applied when constructing the series type
     *
     * ---
     * 📚 Docs: {@link https://www.scichart.com/documentation/js/v4/2d-charts/chart-types/uniform-contours-renderable-series/}
     */
    constructor(webAssemblyContext: TSciChart, options?: IContoursRenderableSeriesOptions);
    /**
     * The minimum Z value for which contours will be drawn.  Defaults to the data z minimum.
     */
    get zMin(): number;
    set zMin(zMin: number);
    /**
     * The maximum Z value for which contours will be drawn.  Defaults to the data z maximum.
     */
    get zMax(): number;
    set zMax(zMax: number);
    /**
     * Gets of sets the step on Z, used to calculate spacing between contours
     */
    get zStep(): number;
    set zStep(zStep: number);
    /**
     * Gets of sets the offset of the first contour, can take positive or negative values.
     * The contours will not drawn outsize the zMin, zMax limits.
     * zOffset larger than zStep will be treated as zOffset mod zStep.
     * If you want to draw a contour at a specific value, set the zMin and zMax either side of it and use zOffset.
     * eg to draw a single contour at 10, set zMin = 9, zMax = 11, zOffset = 1
     */
    get zOffset(): number;
    set zOffset(value: number);
    /**
     * Explicit list of Z values at which to draw contour lines.
     * When set and non-empty, takes precedence over zMin/zMax/zStep/zOffset.
     */
    get zLevels(): number[];
    set zLevels(value: number[]);
    /**
     * Gets or sets the {@link HeatmapColorMap}, which maps heatmap z-values to colors
     */
    get colorMap(): HeatmapColorMap;
    /**
     * Gets or sets the {@link HeatmapColorMap}, which maps heatmap z-values to colors
     */
    set colorMap(colorMap: HeatmapColorMap);
    get colorMapMode(): EContourColorMapMode;
    set colorMapMode(colorMapMode: EContourColorMapMode);
    get zLabelProvider(): LabelProviderBase2D;
    set zLabelProvider(labelProvider: LabelProviderBase2D);
    get majorLineStyle(): TContourLineStyle;
    set majorLineStyle(majorLineStyle: TContourLineStyle);
    get minorLineStyle(): TContourLineStyle;
    set minorLineStyle(minorLineStyle: TContourLineStyle);
    get minorsPerMajor(): number;
    set minorsPerMajor(minorsPerMajor: number);
    getContourDrawingParams(): IContourDrawingParams;
    /** @inheritDoc */
    toPointSeries(resamplingParams?: ResamplingParams): IPointSeries;
    /** @inheritDoc */
    delete(): void;
    /** @inheritDoc */
    toJSON(excludeData?: boolean): import("../../..").TSeriesDefinition;
    /**
     * Called when a property changes on {@link HeatmapColorMap}, and notifies the parent {@link SciChartSurface}
     * that a redraw is required.
     * @param args
     */
    protected colorMapPropertyChanged(args: PropertyChangedEventArgs): void;
    protected newHitTestProvider(): IHitTestProvider;
}