import type { DomainWithMetadata, NormalizedDomain } from 'ag-charts-core';
import type { AgNumericValue } from 'ag-charts-types';
import { AbstractScale } from './abstractScale';
export declare abstract class ContinuousScale<D extends number | bigint | Date, I = number> extends AbstractScale<D, number, I> {
    range: number[];
    static is(value: unknown): value is ContinuousScale<any, any>;
    static readonly defaultTickCount = 5;
    readonly defaultTickCount = 5;
    protected defaultClamp: boolean;
    protected transform?(x: number): number;
    protected transformInvert?(x: number): D;
    private _domain;
    private domainNeedsValueOf;
    private d0Cache;
    private d1Cache;
    private d0Big;
    private d1Big;
    get domain(): D[];
    set domain(values: readonly (D | bigint)[]);
    protected constructor(domain?: D[], range?: number[]);
    abstract toDomain(value: number): D;
    normalizeDomains(...domains: DomainWithMetadata<D>[]): NormalizedDomain<D>;
    calcBandwidth(smallestInterval?: AgNumericValue, minWidth?: 1 | 0): number;
    convert(value: D | AgNumericValue, options?: {
        clamp?: boolean;
    }): number;
    /**
     * Converts `value` after clamping it into the domain extent. Unlike `convert(value, { clamp: true })`,
     * which clamps the output by sorted range order, clamping the input keeps reversed domains oriented so
     * out-of-domain values map to the correct endpoint.
     */
    convertClamped(value: AgNumericValue): number;
    invert(x: number, _nearest?: boolean): any;
    getDomainMinMax(): [undefined, undefined] | [D, D];
    snapshotDomain(): D[];
    private exactEndpoint;
    private startIsMin;
    get domainMin(): D | undefined;
    get domainMax(): D | undefined;
    protected getPixelRange(): number;
}
export declare function normalizeContinuousDomains<D extends number | bigint | Date>(...domains: DomainWithMetadata<D>[]): NormalizedDomain<D>;