/**
 * chartjs-chart-pcp
 * https://github.com/sgratzl/chartjs-chart-pcp
 *
 * Copyright (c) 2019-2023 Samuel Gratzl <sam@sgratzl.com>
 */

import { ChartType, ScriptableAndArrayOptions, CartesianScaleOptions, LinearScaleOptions, ScriptableContext, LogarithmicScaleOptions, LinearScale, LogarithmicScale, LineOptions, Element, ControllerDatasetOptions, CommonHoverOptions, CartesianScaleTypeRegistry, DatasetController, ChartComponent, UpdateMode, Chart, ChartItem, ChartConfiguration, CategoryScaleOptions, CategoryScale } from 'chart.js';

interface IAxisOptions extends CartesianScaleOptions {
    axisWidth: number;
}
interface IAxisProps {
    x: number;
    y: number;
    width: number;
    height: number;
    top: number;
    bottom: number;
    left: number;
    right: number;
}
type ILinearAxisOptions = IAxisOptions & LinearScaleOptions;
declare class LinearAxis extends LinearScale<ILinearAxisOptions> {
    static readonly id = "linearAxis";
    static readonly defaults: any;
    static readonly descriptors: {
        _scriptable: (name: string) => boolean;
        _indexable: (name: string) => boolean;
    };
    constructor();
    update(): number;
    _computeLabelArea(): void;
    draw(c: unknown): void;
}
type ILogarithmicAxisOptions = IAxisOptions & LogarithmicScaleOptions;
declare class LogarithmicAxis extends LogarithmicScale<ILogarithmicAxisOptions> {
    static readonly id = "logarithmicAxis";
    static readonly defaults: any;
    static readonly descriptors: {
        _scriptable: (name: string) => boolean;
        _indexable: (name: string) => boolean;
    };
    constructor();
    _computeLabelArea(): void;
    update(): number;
    draw(c: unknown): void;
}
declare module 'chart.js' {
    interface ElementOptionsByType<TType extends ChartType> {
        linearAxis: ScriptableAndArrayOptions<ILinearAxisOptions, ScriptableContext<TType>>;
        logarithmicAxis: ScriptableAndArrayOptions<ILogarithmicAxisOptions, ScriptableContext<TType>>;
    }
}

interface ILineSegmentOptions extends LineOptions {
    tension: number;
}
interface ILineSegmentProps {
    x: number;
    y: number;
    x1: number;
    y1: number;
    xCPn: number;
    yCPn: number;
    xCPp1: number;
    yCPp1: number;
}
declare class LineSegment extends Element<ILineSegmentProps & AnyObject, ILineSegmentOptions & AnyObject> {
    _getLineParts(props: Pick<ILineSegmentProps, 'x' | 'y' | 'x1' | 'y1'>): {
        d: number;
        k: number;
    };
    inRange(mouseX: number, mouseY: number, useFinalPosition: boolean): boolean;
    tooltipPosition(useFinalPosition: boolean): {
        x: number;
        y: number;
        padding: number;
    };
    getCenterPoint(useFinalPosition: boolean): {
        x: number;
        y: number;
    };
    inXRange(mouseX: number, useFinalPosition: boolean): boolean;
    inYRange(mouseY: number, useFinalPosition: boolean): boolean;
    draw(ctx: CanvasRenderingContext2D): void;
    static readonly id = "lineSegment";
    static readonly defaults: {
        hoverBorderWidth: number;
        hoverBorderColor: string;
        borderCapStyle: string;
        tension: number;
    };
    static readonly defaultRoutes: {
        [property: string]: string;
    } | undefined;
    static readonly descriptors: any;
}
declare module 'chart.js' {
    interface ElementOptionsByType<TType extends ChartType> {
        lineSegment: ScriptableAndArrayOptions<ILineSegmentOptions, ScriptableContext<TType>>;
    }
}

type AnyObject = Record<string, unknown>;
declare class ParallelCoordinatesController extends DatasetController<'pcp', LineSegment & Element<AnyObject, AnyObject>, LinearAxis & Element<AnyObject, AnyObject>> {
    datasetElementType: ChartComponent;
    dataElementType: ChartComponent;
    private _type;
    initialize(): void;
    linkScales(): void;
    private resolveAxisOptions;
    addElements(): void;
    update(mode: UpdateMode): void;
    draw(): void;
    updateAxis(axis: LinearAxis & Element<AnyObject, AnyObject>, mode: UpdateMode): void;
    updateElements(rectangles: (LineSegment & Element<AnyObject, AnyObject>)[], start: number, count: number, mode: UpdateMode): void;
    private _findOtherControllers;
    removeBaseHoverStyle(element: LineSegment & Element<AnyObject, AnyObject>, datasetIndex: number, index: number): void;
    removeHoverStyle(element: LineSegment & Element<AnyObject, AnyObject>, datasetIndex: number, index: number): void;
    setBaseHoverStyle(element: LineSegment & Element<AnyObject, AnyObject>, datasetIndex: number, index: number): void;
    setHoverStyle(element: LineSegment & Element<AnyObject, AnyObject>, datasetIndex: number, index: number): void;
    static readonly id: string;
    static readonly defaults: any;
    static readonly overrides: any;
}
interface IParallelCoordinatesControllerDatasetOptions extends Omit<ControllerDatasetOptions, 'clip'>, Omit<ILinearAxisOptions, 'backgroundColor'>, ScriptableAndArrayOptions<ILineSegmentOptions, ScriptableContext<'pcp'>>, ScriptableAndArrayOptions<CommonHoverOptions, ScriptableContext<'pcp'>> {
    stack: string;
}
type IParallelCoordinatesChartOptions = ILinearAxisOptions;
declare module 'chart.js' {
    interface ChartTypeRegistry {
        pcp: {
            chartOptions: IParallelCoordinatesChartOptions;
            datasetOptions: IParallelCoordinatesControllerDatasetOptions;
            defaultDataPoint: number;
            metaExtensions: Record<string, never>;
            parsedDataType: {
                y: number;
            };
            scales: keyof CartesianScaleTypeRegistry;
        };
    }
}
declare class ParallelCoordinatesChart<DATA extends unknown[] = number[], LABEL = string> extends Chart<'pcp', DATA, LABEL> {
    static id: string;
    constructor(item: ChartItem, config: Omit<ChartConfiguration<'pcp', DATA, LABEL>, 'type'>);
}

declare class LogarithmicParallelCoordinatesController extends ParallelCoordinatesController {
    static readonly id = "logarithmicPcp";
    static readonly defaults: any;
    static readonly overrides: any;
}
interface ILogarithmicParallelCoordinatesControllerDatasetOptions extends Omit<ControllerDatasetOptions, 'clip'>, Omit<ILogarithmicAxisOptions, 'backgroundColor'>, ScriptableAndArrayOptions<ILineSegmentOptions, ScriptableContext<'logarithmicPcp'>>, ScriptableAndArrayOptions<CommonHoverOptions, ScriptableContext<'logarithmicPcp'>> {
    stack: string;
}
type ILogarithmicParallelCoordinatesChartOptions = ILogarithmicAxisOptions;
declare module 'chart.js' {
    interface ChartTypeRegistry {
        logarithmicPcp: {
            chartOptions: ILogarithmicParallelCoordinatesChartOptions;
            datasetOptions: ILogarithmicParallelCoordinatesControllerDatasetOptions;
            defaultDataPoint: number;
            metaExtensions: Record<string, never>;
            parsedDataType: {
                y: number;
            };
            scales: keyof CartesianScaleTypeRegistry;
        };
    }
}
declare class LogarithmicParallelCoordinatesChart<DATA extends unknown[] = number[], LABEL = string> extends Chart<'logarithmicPcp', DATA, LABEL> {
    static id: string;
    constructor(item: ChartItem, config: Omit<ChartConfiguration<'logarithmicPcp', DATA, LABEL>, 'type'>);
}

declare class PCPScale extends CategoryScale {
    getLabels(): string[];
    static readonly id = "pcp";
    static readonly defaults: any;
}
declare module 'chart.js' {
    interface ScaleTypeRegistry {
        pcp: {
            options: CategoryScaleOptions;
        };
    }
}

export { LineSegment, LinearAxis, LogarithmicAxis, LogarithmicParallelCoordinatesChart, LogarithmicParallelCoordinatesController, PCPScale, ParallelCoordinatesChart, ParallelCoordinatesController };
export type { AnyObject, IAxisOptions, IAxisProps, ILineSegmentOptions, ILineSegmentProps, ILinearAxisOptions, ILogarithmicAxisOptions, ILogarithmicParallelCoordinatesChartOptions, ILogarithmicParallelCoordinatesControllerDatasetOptions, IParallelCoordinatesChartOptions, IParallelCoordinatesControllerDatasetOptions };
//# sourceMappingURL=index.d.ts.map