import { Axis, type CreateItemsSeriesOptions, type DataPoint, type IRenderContext, ItemsSeries, type ITransposablePlotElement, type OxyRect, type ScreenPoint, TrackerHitResult, type TrackerStringFormatterArgs, type TrackerStringFormatterType } from '..';
export interface CreateXYAxisSeriesOptions extends CreateItemsSeriesOptions {
    xAxisKey?: string;
    yAxisKey?: string;
}
export declare const DefaultXYAxisSeriesOptions: CreateXYAxisSeriesOptions;
export declare const ExtendedDefaultXYAxisSeriesOptions: {
    DefaultXYAxisSeriesOptions: CreateXYAxisSeriesOptions;
    itemsSource?: any[] | undefined;
    background?: string | undefined;
    isVisible?: boolean | undefined;
    title?: string | undefined;
    legendKey?: string | undefined;
    seriesGroupName?: string | undefined;
    renderInLegend?: boolean | undefined;
    trackerStringFormatter?: 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;
};
/**
 * Provides an abstract base class for series that are related to an X-axis and a Y-axis.
 */
export declare abstract class XYAxisSeries extends ItemsSeries implements ITransposablePlotElement {
    /**
     * The default tracker formatter
     */
    static readonly DefaultTrackerFormatter: TrackerStringFormatterType;
    /**
     * The default x-axis title
     */
    protected static readonly defaultXAxisTitle = "X";
    /**
     * The default y-axis title
     */
    protected static readonly defaultYAxisTitle = "Y";
    /**
     * A format function used for the tracker. The default depends on the series.
     * The arguments for the formatter may be different for each type of series. See the documentation.
     */
    trackerStringFormatter?: TrackerStringFormatterType;
    /**
     * Initializes a new instance of the XYAxisSeries class.
     */
    protected constructor(opt?: CreateXYAxisSeriesOptions);
    private _maxX;
    /**
     * Gets or sets the maximum x-coordinate of the dataset.
     */
    get maxX(): number;
    protected set maxX(value: number);
    private _maxY;
    /**
     * Gets or sets the maximum y-coordinate of the dataset.
     */
    get maxY(): number;
    protected set maxY(value: number);
    private _minX;
    /**
     * Gets or sets the minimum x-coordinate of the dataset.
     */
    get minX(): number;
    protected set minX(value: number);
    private _minY;
    /**
     * Gets or sets the minimum y-coordinate of the dataset.
     */
    get minY(): number;
    protected set minY(value: number);
    private _xAxis?;
    /**
     * Gets the x-axis.
     */
    get xAxis(): Axis | undefined;
    /**
     * Gets or sets the x-axis key. The default is null.
     */
    xAxisKey?: string;
    private _yAxis?;
    /**
     * Gets the y-axis.
     */
    get yAxis(): Axis | undefined;
    /**
     * Gets or sets the y-axis key. The default is null.
     */
    yAxisKey?: string;
    /**
     * Gets or sets a value indicating whether the X coordinate of all data point increases monotonically.
     */
    protected isXMonotonic: boolean;
    /**
     * Gets or sets the last visible window start position in the data points collection.
     */
    protected windowStartIndex: number;
    /**
     * Gets the clipping rectangle of the series.
     * @returns The clipping rectangle.
     */
    getClippingRect(): OxyRect;
    /**
     * Gets the rectangle the series uses on the screen (screen coordinates).
     * @returns The rectangle.
     */
    getScreenRectangle(): OxyRect;
    /**
     * Inverse transforms the specified screen point to a data point.
     * @param p The screen point.
     * @returns The data point.
     */
    inverseTransform(p: ScreenPoint): DataPoint;
    /**
     * Renders the legend symbol on the specified rendering context.
     * @param rc The rendering context.
     * @param legendBox The legend rectangle.
     */
    renderLegend(rc: IRenderContext, legendBox: OxyRect): Promise<void>;
    /**
     * Transforms the specified data point to a screen point.
     * @param p The data point.
     * @returns The screen point.
     */
    transform(p: DataPoint): ScreenPoint;
    /**
     * Check if this data series requires X/Y axes. (e.g. Pie series do not require axes)
     * @returns True if axes are required.
     * @internal
     */
    areAxesRequired(): boolean;
    /**
     * Ensures that the axes of the series are defined.
     * @internal
     */
    ensureAxes(): void;
    /**
     * Check if the data series is using the specified axis.
     * @param axis An axis.
     * @returns True if the axis is in use.
     * @internal
     */
    isUsing(axis: Axis): boolean;
    /**
     * Sets default values from the plot model.
     * @internal
     */
    setDefaultValues(): void;
    /**
     * Updates the axes to include the max and min of this series.
     * @internal
     */
    updateAxisMaxMin(): void;
    /**
     * Updates the data.
     * @internal
     */
    updateData(): void;
    /**
     * Updates the maximum and minimum values of the series.
     * @internal
     */
    updateMaxMin(): void;
    /**
     * Gets the point on the curve that is nearest the specified point.
     * @param points The point list.
     * @param startIdx The index to start from.
     * @param point The point.
     * @returns A tracker hit result if a point was found.
     * The Text property of the result will not be set, since the formatting depends on the various series.
     */
    protected getNearestInterpolatedPointInternal(points: DataPoint[], startIdx: number, point: ScreenPoint): TrackerHitResult | undefined;
    /**
     * Gets the nearest point.
     * @param points The points (data coordinates).
     * @param startIdx The index to start from.
     * @param point The point (screen coordinates).
     * @returns A TrackerHitResult if a point was found, null otherwise.
     * The Text property of the result will not be set, since the formatting depends on the various series.
     */
    protected getNearestPointInternal(points: DataPoint[], startIdx: number, point: ScreenPoint): TrackerHitResult | undefined;
    /**
     * Determines whether the specified point is valid.
     * @param pt The point.
     * @returns true if the point is valid; otherwise, false.
     */
    protected isValidPoint(pt: DataPoint): boolean;
    /**
     * Determines whether the specified point is valid.
     * @param x The x coordinate.
     * @param y The y coordinate.
     * @returns true if the point is valid; otherwise, false.
     */
    protected isValidPoint2(x: number, y: number): boolean;
    /**
     * Updates the Max/Min limits from the specified DataPoint list.
     * @param points The list of points.
     * @throws Error if points is null.
     */
    protected internalUpdateMaxMin(points: DataPoint[]): void;
    /**
     * Updates the Max/Min limits from the specified collection.
     * @param items The items.
     * @param xmin A function that provides the x minimum for each item.
     * @param xmax A function that provides the x maximum for each item.
     * @param ymin A function that provides the y minimum for each item.
     * @param ymax A function that provides the y maximum for each item.
     * @throws Error if items is null.
     */
    protected internalUpdateMaxMin2<T>(items: T[], xmin: (item: T) => number, xmax: (item: T) => number, ymin: (item: T) => number, ymax: (item: T) => number): void;
    /**
     * Verifies that both axes are defined.
     */
    protected verifyAxes(): void;
    /**
     * Updates visible window start index.
     * @param items Data points.
     * @param xgetter Function that gets data point X coordinate.
     * @param targetX X coordinate of visible window start.
     * @param lastIndex Last window index.
     * @returns The new window start index.
     */
    protected updateWindowStartIndex<T>(items: T[], xgetter: (item: T) => number, targetX: number, lastIndex: number): number;
    /**
     * Finds the index of max(x) <= target x in a list of data points
     * @param items vector of data points
     * @param xgetter Function that gets data point X coordinate.
     * @param targetX target x.
     * @param initialGuess initial guess index.
     * @returns index of x with max(x) <= target x or 0 if cannot find
     */
    findWindowStartIndex<T>(items: T[], xgetter: (item: T) => number, targetX: number, initialGuess: number): number;
    protected formatDefaultTrackerString(item: any, p?: DataPoint, addOtherArgs?: (args: TrackerStringFormatterArgs) => void): string | undefined;
    protected getJsonIgnoreProperties(): string[];
    protected getElementDefaultValues(): any;
}
//# sourceMappingURL=XYAxisSeries.d.ts.map