import { Axis, type CreateAxisOptions, type ScreenPoint, type TickValuesType } from '..';
export interface CreateLogarithmicAxisOptions extends CreateAxisOptions {
    base?: number;
    powerPadding?: boolean;
}
export declare const DefaultLogarithmicAxisOptions: CreateLogarithmicAxisOptions;
export declare const ExtendedDefaultLogarithmicAxisOptions: {
    base?: number | undefined;
    powerPadding?: boolean | undefined;
    position?: import('..').AxisPosition | undefined;
    positionTier?: number | undefined;
    isAxisVisible?: boolean | undefined;
    layer?: import('..').AxisLayer | undefined;
    absoluteMaximum?: number | undefined;
    absoluteMinimum?: number | undefined;
    minimum?: number | undefined;
    maximum?: number | undefined;
    minorStep?: number | undefined;
    majorStep?: number | undefined;
    minimumMinorStep?: number | undefined;
    minimumMajorStep?: number | undefined;
    minimumMajorIntervalCount?: number | undefined;
    maximumMajorIntervalCount?: number | undefined;
    minimumPadding?: number | undefined;
    maximumPadding?: number | undefined;
    minimumRange?: number | undefined;
    maximumRange?: number | undefined;
    minimumDataMargin?: number | undefined;
    maximumDataMargin?: number | undefined;
    minimumMargin?: number | undefined;
    maximumMargin?: number | undefined;
    tickStyle?: import('..').TickStyle | undefined;
    ticklineColor?: string | undefined;
    minorTicklineColor?: string | undefined;
    axislineStyle?: import('..').LineStyle | undefined;
    axislineColor?: string | undefined;
    axislineThickness?: number | undefined;
    majorGridlineStyle?: import('..').LineStyle | undefined;
    majorGridlineColor?: string | undefined;
    majorGridlineThickness?: number | undefined;
    minorGridlineStyle?: import('..').LineStyle | undefined;
    minorGridlineColor?: string | undefined;
    minorGridlineThickness?: number | undefined;
    extraGridlines?: number[] | undefined;
    extraGridlineStyle?: import('..').LineStyle | undefined;
    extraGridlineColor?: string | undefined;
    extraGridlineThickness?: number | undefined;
    minorTickSize?: number | undefined;
    majorTickSize?: number | undefined;
    startPosition?: number | undefined;
    stringFormatter?: import('..').AxisStringFormatterType | undefined;
    endPosition?: number | undefined;
    title?: string | undefined;
    titlePosition?: number | undefined;
    unit?: string | undefined;
    useSuperExponentialFormat?: boolean | undefined;
    titleFormatter?: import('..').AxisTitleFormatterType | undefined;
    titleClippingLength?: number | undefined;
    titleColor?: string | undefined;
    titleFontSize?: number | undefined;
    titleFontWeight?: number | undefined;
    clipTitle?: boolean | undefined;
    angle?: number | undefined;
    isZoomEnabled?: boolean | undefined;
    key?: string | undefined;
    isPanEnabled?: boolean | undefined;
    filterMinValue?: number | undefined;
    filterMaxValue?: number | undefined;
    filterFunction?: ((value: number) => boolean) | undefined;
    intervalLength?: number | undefined;
    axisDistance?: number | undefined;
    axisTitleDistance?: number | undefined;
    axisTickToLabelDistance?: number | undefined;
    dataMaximum?: number | undefined;
    dataMinimum?: number | undefined;
    labelFormatter?: import('..').AxisStringFormatterType | undefined;
    positionAtZeroCrossing?: boolean | undefined;
    cropGridlines?: boolean | undefined;
    positionTierMaxShift?: number | undefined;
    positionTierMinShift?: number | undefined;
    positionTierSize?: number | 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;
};
/**
 * Represents an axis with logarithmic scale.
 * @see {@link http://en.wikipedia.org/wiki/Logarithmic_scale}
 */
export declare class LogarithmicAxis extends Axis {
    /**
     * The logarithmic base (normally 10).
     */
    base: number;
    /**
     * A value indicating whether the actualMaximum and actualMinimum values should be padded to the nearest power of the Base.
     */
    powerPadding: boolean;
    /**
     * The logarithmic actual maximum value of the axis.
     */
    protected actualLogMaximum: number;
    /**
     * The logarithmic actual minimum value of the axis.
     */
    protected actualLogMinimum: number;
    /**
     * The logarithmic clip maximum value of the axis.
     */
    protected logClipMaximum: number;
    /**
     * The logarithmic clip minimum value of the axis.
     */
    protected logClipMinimum: number;
    /**
     * Initializes a new instance of the LogarithmicAxis class.
     */
    constructor(opt?: CreateLogarithmicAxisOptions);
    getElementName(): string;
    /**
     * Gets the coordinates used to draw ticks and tick labels (numbers or category names).
     */
    getTickValues(): TickValuesType;
    /**
     * Determines whether the axis is used for X/Y values.
     * @returns true if it is an XY axis; otherwise, false.
     */
    isXyAxis(): boolean;
    /**
     * Determines whether the axis is logarithmic.
     * @returns true if it is a logarithmic axis; otherwise, false.
     */
    isLogarithmic(): boolean;
    /**
     * Pans the specified axis.
     * @param ppt The previous point (screen coordinates).
     * @param cpt The current point (screen coordinates).
     */
    pan(ppt: ScreenPoint, cpt: ScreenPoint): void;
    /**
     * Inverse transforms the specified screen coordinate. This method can only be used with non-polar coordinate systems.
     * @param sx The screen coordinate.
     * @returns The value.
     */
    inverseTransform(sx: number): number;
    /**
     * Transforms the specified coordinate to screen coordinates.
     * @param x The value.
     * @returns The transformed value (screen coordinate).
     */
    transform(x: number): number;
    /**
     * Zooms the axis at the specified coordinate.
     * @param factor The zoom factor.
     * @param x The coordinate to zoom at.
     */
    zoomAt(factor: number, x: number): void;
    /**
     * Raises all elements of a List to the power of this.base.
     * @param logInput The input values.
     * @param clip If true, discards all values that are not in the axis range.
     * @returns A new array containing the resulting values.
     * @internal
     */
    protected powList(logInput: number[], clip?: boolean): number[];
    /**
     * Applies the logarithm with this.base to all elements of a List.
     * @param input The input values.
     * @param clip If true, discards all values that are not in the axis range.
     * @returns A new array containing the resulting values.
     * @internal
     */
    protected logList(input: number[], clip?: boolean): number[];
    /**
     * Calculates ticks of the decades in the axis range with a specified step size.
     * @param step The step size.
     * @returns A new array containing the decade ticks.
     * @internal
     */
    protected decadeTicks(step?: number): number[];
    /**
     * Calculates logarithmic ticks of the decades in the axis range with a specified step size.
     * @param step The step size.
     * @returns A new array containing the logarithmic decade ticks.
     * @internal
     */
    protected logDecadeTicks(step?: number): number[];
    /**
     * Calculates logarithmic ticks of all decades in the axis range and their subdivisions.
     * @param clip If true (default), the lowest and highest decade are clipped to the axis range.
     * @returns A new array containing the logarithmic decade ticks.
     * @internal
     */
    protected logSubdividedDecadeTicks(clip?: boolean): number[];
    /**
     * Calculates ticks of all decades in the axis range and their subdivisions.
     * @param clip If true (default), the lowest and highest decade are clipped to the axis range.
     * @returns A new array containing the decade ticks.
     * @internal
     */
    protected subdividedDecadeTicks(clip?: boolean): number[];
    /**
     * Chooses from a list of candidates so that the resulting array matches the logDesiredStepSize as far as possible.
     * @param logCandidates The candidates.
     * @param logDesiredStepSize The desired logarithmic step size.
     * @returns A new array containing the chosen candidates.
     * @internal
     */
    protected alignTicksToCandidates(logCandidates: number[], logDesiredStepSize: number): number[];
    /**
     * Chooses from a list of candidates so that the resulting array matches the logDesiredStepSize as far as possible.
     * @param logCandidates The candidates.
     * @param logDesiredStepSize The desired logarithmic step size.
     * @returns A new array containing the chosen logarithmic candidates.
     * @internal
     */
    protected logAlignTicksToCandidates(logCandidates: number[], logDesiredStepSize: number): number[];
    /**
     * Calculates minor tick candidates for a given set of major candidates.
     * @param logMajorCandidates The major candidates.
     * @param logDesiredMajorStepSize The desired major step size.
     * @returns A new array containing the minor candidates.
     * @internal
     */
    protected logCalculateMinorCandidates(logMajorCandidates: number[], logDesiredMajorStepSize: number): number[];
    /**
     * Subdivides a logarithmic range into multiple, evenly-spaced (in linear scale!) ticks. The number of ticks and the tick intervals are adapted so
     * that the resulting steps are "nice" numbers.
     * @param logTicks The array the computed steps will be added to.
     * @param steps The minimum number of steps.
     * @param logFrom The start of the range.
     * @param logTo The end of the range.
     * @internal
     */
    protected logSubdivideInterval(logTicks: number[], steps: number, logFrom: number, logTo: number): void;
    /**
     * Updates the actualMaximum and actualMinimum values.
     * If the user has zoomed/panned the axis, the internal viewMaximum/viewMinimum
     * values will be used. If maximum or minimum have been set, these values will be used. Otherwise the maximum and minimum values
     * of the series will be used, including the 'padding'.
     * @internal
     */
    updateActualMaxMin(): void;
    /**
     * Invoked when actualMinimum, actualMaximum, clipMinimum, and clipMaximum are changed.
     */
    protected actualMaximumAndMinimumChangedOverride(): void;
    /**
     * Applies a transformation after the inverse transform of the value. This is used in logarithmic axis.
     * @param x The value to transform.
     * @returns The transformed value.
     */
    protected postInverseTransform(x: number): number;
    /**
     * Applies a transformation before the transform the value. This is used in logarithmic axis.
     * @param x The value to transform.
     * @returns The transformed value.
     */
    protected preTransform(x: number): number;
    /**
     * Coerces the actual maximum and minimum values.
     */
    protected coerceActualMaxMin(): void;
    /**
     * Calculates the actual maximum value of the axis, including the maximumPadding.
     * @returns The new actual maximum value of the axis.
     * Must be called before calculateActualMinimum
     */
    protected calculateActualMaximum(): number;
    /**
     * Calculates the actual minimum value of the axis, including the minimumPadding.
     * @returns The new actual minimum value of the axis.
     * Must be called after calculateActualMaximum
     */
    protected calculateActualMinimum(): number;
    protected getElementDefaultValues(): any;
}
//# sourceMappingURL=LogarithmicAxis.d.ts.map