import { type CreateLineSeriesOptions, type IRenderContext, LineSeries, LineStyle, type OxyColor, type OxyRect, type ScreenPoint } from '..';
export interface DataRange {
    minimum: number;
    maximum: number;
}
export declare function newDataRange(min: number, max: number): DataRange;
/**
 * Represents an interval defined by two numbers.
 */
export declare class DataRangeHelper {
    /**
     * Gets the difference between maximum and minimum.
     */
    static range(dr: DataRange): number;
    /**
     * Determines whether the specified value lies
     * within the closed interval of the data range.
     * @param dr
     * @param value The value to be checked.
     * @returns true if value in range, otherwise false.
     */
    static contains(dr: DataRange, value: number): boolean;
    /**
     * Determines whether the specified data range
     * intersects with this instance.
     * @param dr
     * @param other the other interval to be checked.
     * @returns true if intersects, otherwise false.
     */
    static intersectsWith(dr: DataRange, other: DataRange): boolean;
}
export interface CreateExtrapolationLineSeriesOptions extends CreateLineSeriesOptions {
    extrapolationColor?: OxyColor;
    extrapolationDashes?: number[];
    extrapolationLineStyle?: LineStyle;
    ignoreExtraplotationForScaling?: boolean;
    intervals?: DataRange[];
}
export declare const DefaultExtrapolationLineSeriesOptions: CreateExtrapolationLineSeriesOptions;
export declare const ExtendedDefaultExtrapolationLineSeriesOptions: {
    color?: string | undefined;
    brokenLineColor?: string | undefined;
    brokenLineStyle?: LineStyle | undefined;
    brokenLineThickness?: number | undefined;
    dashes?: number[] | undefined;
    decimator?: ((points: ScreenPoint[], result: ScreenPoint[]) => void) | undefined;
    labelStringFormatter?: import('..').LabelStringFormatterType | undefined;
    labelMargin?: number | undefined;
    lineJoin?: import('..').LineJoin | undefined;
    lineStyle?: LineStyle | undefined;
    lineLegendPosition?: import('..').LineLegendPosition | undefined;
    markerFill?: string | undefined;
    markerOutline?: ScreenPoint[] | undefined;
    markerResolution?: number | undefined;
    markerSize?: number | undefined;
    markerStroke?: string | undefined;
    markerStrokeThickness?: number | undefined;
    markerType?: import('..').MarkerType | undefined;
    minimumSegmentLength?: number | undefined;
    interpolationAlgorithm?: import('..').IInterpolationAlgorithm | undefined;
    strokeThickness?: number | undefined;
    points?: import('..').DataPoint[] | undefined;
    canTrackerInterpolatePoints?: boolean | undefined;
    dataFieldX?: string | undefined;
    dataFieldY?: string | undefined;
    mapping?: ((item: any) => import('..').DataPoint) | undefined;
    xAxisKey?: string | undefined;
    yAxisKey?: string | undefined;
    itemsSource?: any[] | undefined;
    background?: string | undefined;
    isVisible?: boolean | undefined;
    title?: string | undefined;
    legendKey?: string | undefined;
    seriesGroupName?: string | undefined;
    renderInLegend?: boolean | undefined;
    trackerStringFormatter?: import('..').TrackerStringFormatterType | undefined;
    trackerKey?: string | undefined;
    font?: string | undefined;
    fontSize?: number | undefined;
    fontWeight?: number | undefined;
    tag?: any;
    textColor?: string | undefined;
    edgeRenderingMode?: import('..').EdgeRenderingMode | undefined;
    toolTip?: string | undefined;
    selectable?: boolean | undefined;
    selectionMode?: import('..').SelectionMode | undefined;
    DefaultXYAxisSeriesOptions: import('..').CreateXYAxisSeriesOptions;
};
/** Represents a series where the line can be rendered using a different style
 * or color in defined intervals of X. The style specified in the LineStyle
 * property determines how the line is rendered in these intervals. Outside
 * the intervals the style is always solid.
 */
export declare class ExtrapolationLineSeries extends LineSeries {
    /** Default color for the extrapolated parts of the curve. Currently, hard-coded. */
    private readonly _defaultExtrapolationColor;
    /** Default line style for the extrapolated parts of the curve. Currently, hard-coded. */
    private readonly _defaultExtrapolationLineStyle;
    private _orderedIntervals;
    constructor(opt?: CreateExtrapolationLineSeriesOptions);
    getElementName(): string;
    /** Gets or sets the color for the part of the line that is inside an interval. */
    extrapolationColor: OxyColor;
    /** Gets the actual extrapolation color. */
    get actualExtrapolationColor(): OxyColor;
    /** Gets or sets the dash array for the extrapolated intervals of the rendered line
     * (overrides ExtrapolationLineStyle). The default is undefined.
     */
    extrapolationDashes?: number[];
    /** Gets or sets the style for the extrapolated parts of the line. */
    extrapolationLineStyle: LineStyle;
    /** Gets the actual extrapolation line style. */
    get actualExtrapolationLineStyle(): LineStyle;
    /** Gets or sets a value indicating whether the extrapolated regions of the series will
     * be taken into account when calculating the minima and maxima of the dataset.
     * These regions will hence also be ignored when auto-scaling the axes.
     */
    ignoreExtraplotationForScaling: boolean;
    /** Gets the list of X intervals within which the line is rendered using the second color and style. */
    intervals: DataRange[];
    /** Gets the actual dash array for the extrapolated parts of the line. */
    protected get actualExtrapolationDashArray(): number[];
    /** Renders the legend symbol for the extrapolation line series on the
     * specified rendering context. Both lines (normal and extrapolated)
     * are displayed.
     */
    renderLegend(rc: IRenderContext, legendBox: OxyRect): Promise<void>;
    /**
     * Updates the data and sorts the intervals.
     * @internal
     * */
    updateData(): void;
    /**
     * Updates the maximum and minimum values of the series.
     * @internal
     * */
    updateMaxMin(): void;
    /**
     * Renders a continuous line.
     * @param rc The render context.
     * @param pointsToRender The points to render.
     */
    protected renderLine(rc: IRenderContext, pointsToRender: ScreenPoint[]): Promise<void>;
    /**
     * Creates clipping rectangles for the parts of the line which are either
     * rendered in normal style or in extrapolation style.
     */
    private createClippingRectangles;
    /**
     * Returns a flat sequence of doubles containing alternating minima
     * and maxima of the original data range intervals.
     */
    private flatten;
    /**
     * Renders the part of the line which is given by the provided list of screen points.
     */
    private renderLinePart;
    /**
     * Sorts the intervals by their minimum and merges those intervals which overlap, i.e.
     * replaces them by their union.
     */
    private mergeOverlaps;
    /**
     * Checks whether the given x-value is within any of the
     * ordered intervals using binary search.
     * @param x The value to be checked for.
     * @returns true if x is inside any interval.
     */
    private inAnyInterval;
    /**
     * Checks whether the given x-value is within the provided interval.
     * @param interval The interval to check against.
     * @param x The value to be checked.
     * @returns 0 if x is within inclusive interval, -1 if x smaller interval's min, 1 if x larger interval's max.
     */
    private compare;
    protected getElementDefaultValues(): any;
}
//# sourceMappingURL=ExtrapolationLineSeries.d.ts.map