import { __extends } from "tslib";
import { EventEmitter, Output, Component, Input } from '@angular/core';
import { delegateCombine } from "igniteui-angular-core";
import { AxisRangeBufferMode_$type } from "./AxisRangeBufferMode";
import { IgxAxisComponent } from "./igx-axis-component";
import { ensureBool, ensureEnum, arrayFindByName } from "igniteui-angular-core";
import * as i0 from "@angular/core";
/**
 * Represents the base class for all IgxDataChartComponent numeric axes.
*/
var IgxNumericAxisBaseComponent = /** @class */ /*@__PURE__*/ (function (_super) {
    __extends(IgxNumericAxisBaseComponent, _super);
    function IgxNumericAxisBaseComponent() {
        var _this = _super.call(this) || this;
        _this._actualMinimumValueChange = null;
        _this._actualMaximumValueChange = null;
        _this._actualIntervalChange = null;
        _this._actualMinorIntervalChange = null;
        return _this;
    }
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "i", {
        /**
                                     * @hidden
                                     */
        get: function () {
            return this._implementation;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "isNumeric", {
        /**
         * Gets or sets if the current axis is of numeric axis type
        */
        get: function () {
            return this.i.dh;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "autoRangeBufferMode", {
        /**
         * Gets or sets how the numeric axis will adjust its range buffer to less closely fix the data from the series.
        */
        get: function () {
            return this.i.ok;
        },
        set: function (v) {
            this.i.ok = ensureEnum(AxisRangeBufferMode_$type, v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "minimumValue", {
        /**
         * Gets or sets the MinimumValue property.
        *
        * Used to set the minimum value of a numeric axis. To get the minimum value in effect on a numeric axis use `ActualMinimumValue`.
        *
        * ```ts
        * this.yAxis.minimumValue = 0;
        * ```
        *
        * ```html
        * <igx-data-chart
        *     [dataSource]="data">
        *     <igx-category-x-axis
        *         label="label"
        *         #xAxis>
        *     </igx-category-x-axis>
        *     <igx-numeric-y-axis
        *         minimumValue=0
        *         #yAxis>
        *     </igx-numeric-y-axis>
        *     <igx-column-series
        *         [xAxis]="xAxis"
        *         [yAxis]="yAxis"
        *         valueMemberPath="value">
        *     </igx-column-series>
        * </igx-data-chart>
        * ```
        */
        get: function () {
            return this.i.p3;
        },
        set: function (v) {
            this.i.p3 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualMinimumValue", {
        /**
         * Gets the effective minimum value for the current numeric axis object.
        *
        * ```ts
        * let effectiveMinValue: number = yAxis.actualMinimumValue;
        * ```
        */
        get: function () {
            return this.i.pr;
        },
        set: function (v) {
            this.i.pr = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualVisibleMinimumValue", {
        /**
         * Gets the effective minimum value for the current numeric axis object.
        *
        * The `actualVisibleMinimumValue` is used to get the current visible maximum value for the a numeric axis. Note, at times the `actualVisibleMinimumValue` may differ from the `actualMinimumValue`, for example when the chart is zoomed.
        *
        * ```ts
        * let effectiveVisibleMinValue: number = yAxis.actualVisibleMinimumValue;
        * ```
        */
        get: function () {
            return this.i.pu;
        },
        set: function (v) {
            this.i.pu = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "maximumValue", {
        /**
         * Gets or sets the MaximumValue property.
        *
        * Used to set the maximum value of a numeric axis. To get the maximum value in effect on a numeric axis use `ActualMaximumValue`.
        *
        * ```ts
        * this.yAxis.maximumValue = 80;
        * ```
        *
        * ```html
        * <igx-data-chart
        *     [dataSource]="data">
        *     <igx-category-x-axis
        *         label="label"
        *         #xAxis>
        *     </igx-category-x-axis>
        *     <igx-numeric-y-axis
        *         maximumValue=80
        *         #yAxis>
        *     </igx-numeric-y-axis>
        *     <igx-line-series
        *         [xAxis]="xAxis"
        *         [yAxis]="yAxis"
        *         valueMemberPath="value">
        *     </igx-line-series>
        * </igx-data-chart>
        * ```
        */
        get: function () {
            return this.i.p2;
        },
        set: function (v) {
            this.i.p2 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualMaximumValue", {
        /**
         * Gets the effective maximum value for the current numeric axis object.
        *
        * ```ts
        * let effectiveMaxValue: number = yAxis.actualMaximumValue;
        * ```
        */
        get: function () {
            return this.i.pq;
        },
        set: function (v) {
            this.i.pq = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualVisibleMaximumValue", {
        /**
         * Gets the effective visible maximum value for the current numeric axis object.
        *
        * The `ActualVisibleMaximumValue` is used to get the current visible maximum value for the a numeric axis. Note, at times the `ActualVisibleMaximumValue` may differ from the `ActualMaximumValue`, for example when the chart is zoomed.
        *
        * ```ts
        * let effectiveVisibleMaxValue: number = yAxis.actualVisibleMaximumValue;
        * ```
        */
        get: function () {
            return this.i.pt;
        },
        set: function (v) {
            this.i.pt = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "interval", {
        /**
         * Gets or sets the Interval property.
        *
        * The `Interval` is used to get or set the numeric axis major interval which specifies how frequent major gridlines and axis labels are rendered on an axis.
        *
        * ```ts
        * this.yAxis.interval = 20;
        * ```
        *
        * ```html
        * <igx-data-chart
        *       [dataSource]="data">
        *       <igx-category-x-axis
        *         label="label"
        *         #xAxis
        *         >
        *       </igx-category-x-axis>
        *       <igx-numeric-y-axis
        *         interval="20"
        *         #yAxis>
        *       </igx-numeric-y-axis>
        *
        *       <igx-column-series
        *         [xAxis]="xAxis"
        *         [yAxis]="yAxis"
        *         valueMemberPath="value">
        *       </igx-column-series>
        * </igx-data-chart>
        * ```
        */
        get: function () {
            return this.i.pz;
        },
        set: function (v) {
            this.i.pz = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualInterval", {
        /**
         * Gets the effective value for the current Interval.
        *
        * ```ts
        * let effectiveInterval: number = yAxis.actualInterval;
        * ```
        */
        get: function () {
            return this.i.pp;
        },
        set: function (v) {
            this.i.pp = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualMaxPrecision", {
        /**
         * Gets the effective value for the current max precision.
        */
        get: function () {
            return this.i.qa;
        },
        set: function (v) {
            this.i.qa = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "maxPrecision", {
        /**
         * Gets or sets the the maximum precision to use for the auto interval.
        */
        get: function () {
            return this.i.qg;
        },
        set: function (v) {
            this.i.qg = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "shouldApplyMaxPrecisionWhenZoomed", {
        /**
         * Gets or sets the the maximum precision to use for the auto interval.
        */
        get: function () {
            return this.i.pf;
        },
        set: function (v) {
            this.i.pf = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "minorInterval", {
        /**
         * Gets or sets the MinorInterval property.
        *
        * The `MinorInterval` is used to get or set the numeric axis minor interval which specifies how frequent minor gridlines are rendered on an axis. Please note, in order for minor gridlines to be displayed the following may also need to be set: `MinorStroke`, `MinorStrokeThickness`.
        *
        * ```ts
        * this.yAxis.minorInterval = 2.5;
        * this.yAxis.minorStroke = 'blue';
        * this.yAxis.minorStrokeThickness = 1;
        * ```
        *
        * ```html
        * <igx-data-chart
        *     [dataSource]="data" >
        *     <igx-category-x-axis
        *         label="label"
        *         #xAxis>
        *     </igx-category-x-axis>
        *     <igx-numeric-y-axis
        *         minorInterval= 2.5
        *         minorStroke="blue"
        *         #yAxis>
        *     </igx-numeric-y-axis>
        *     <igx-column-series
        *         [xAxis]="xAxis"
        *         [yAxis]="yAxis"
        *         valueMemberPath="value">
        *     </igx-column-series>
        * </igx-data-chart>
        * ```
        */
        get: function () {
            return this.i.p4;
        },
        set: function (v) {
            this.i.p4 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualMinorInterval", {
        /**
         * Gets the effective value for the current MinorInterval.
        *
        * ```ts
        * let effectiveMinorInterval: number = yAxis.actualMinorInterval;
        * ```
        */
        get: function () {
            return this.i.ps;
        },
        set: function (v) {
            this.i.ps = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "referenceValue", {
        /**
         * Gets or sets the ReferenceValue property.
        *
        * Used to get or set a reference value on a numeric axis which when used with an area, bar, or column series will result in the series shapes being drawn above or below the specified value.
        *
        * ```ts
        * this.yAxis.referenceValue = 30;
        * ```
        *
        * ```html
        * <igx-data-chart
        *     [dataSource]="data">
        *     <igx-category-x-axis
        *         label="label"
        *         #xAxis>
        *     </igx-category-x-axis>
        *     <igx-numeric-y-axis
        *         referenceValue=30
        *         #yAxis>
        *     </igx-numeric-y-axis>
        *     <igx-column-series
        *         [xAxis]="xAxis"
        *         [yAxis]="yAxis"
        *         valueMemberPath="value">
        *     </igx-column-series>
        * </igx-data-chart>
        * ```
        */
        get: function () {
            return this.i.p5;
        },
        set: function (v) {
            this.i.p5 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "isLogarithmic", {
        /**
         * Gets or sets the IsLogarithmic property.
        *
        * `IsLogarithmic` is used to get or set whether the numeric axis scaler is in linear or logarithmic mode. For logarithmic scaling, this can be used in conjunction with `LogarithmBase` to further define the logarithmic scale.
        *
        * ```ts
        * this.yAxis.isLogarithmic= true;
        * this.yAxis.logarithmBase = 2;
        * ```
        *
        * ```html
        * <igx-data-chart
        *       [dataSource]="data">
        *       <igx-category-x-axis
        *         label="label"
        *         #xAxis>
        *       </igx-category-x-axis>
        *       <igx-numeric-y-axis
        *         isLogarithmic=true
        *         logarithmBase=2
        *         #yAxis>
        *       </igx-numeric-y-axis>
        *       <igx-line-series
        *         [xAxis]="xAxis"
        *         [yAxis]="yAxis"
        *         valueMemberPath="value">
        *       </igx-line-series>
        * </igx-data-chart>
        * ```
        */
        get: function () {
            return this.i.pb;
        },
        set: function (v) {
            this.i.pb = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualIsLogarithmic", {
        /**
         * Determines if the axis has a valid logarithmic scale.
        *
        * ```ts
        * let effectiveLogarithmic: boolean = this.yAxis.actualIsLogarithmic
        * ```
        */
        get: function () {
            return this.i.o2;
        },
        set: function (v) {
            this.i.o2 = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "favorLabellingScaleEnd", {
        /**
         * Gets or sets whether the axis should favor emitting a label at the end of the scale.
        */
        get: function () {
            return this.i.o6;
        },
        set: function (v) {
            this.i.o6 = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "logarithmBase", {
        /**
         * Gets or sets the LogarithmBase property.
        *
        * `LogarithmBase` is used to get or set logarithm base when a numeric axis is in Logarithmic scale mode. For logarithmic scaling, this is used in conjunction with `IsLogarithmic` or `ScaleMode` to set logarithmic scaling.
        *
        * ```ts
        * this.yAxis.scaleMode = NumericScaleMode.Logarithmic;
        * this.yAxis.logarithmBase = 2;
        * ```
        *
        * ```html
        * <igx-data-chart
        *       [dataSource]="data">
        *       <igx-category-x-axis
        *         label="label"
        *         #xAxis>
        *       </igx-category-x-axis>
        *       <igx-numeric-y-axis
        *         scaleMode="Logarithmic"
        *         logarithmBase=2
        *         #yAxis>
        *       </igx-numeric-y-axis>
        *       <igx-line-series
        *         [xAxis]="xAxis"
        *         [yAxis]="yAxis"
        *         valueMemberPath="value">
        *       </igx-line-series>
        * </igx-data-chart>
        * ```
        */
        get: function () {
            return this.i.qe;
        },
        set: function (v) {
            this.i.qe = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "companionAxisInterval", {
        /**
         * Gets or sets interval of labels on the secondary axis.
        */
        get: function () {
            return this.i.pv;
        },
        set: function (v) {
            this.i.pv = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "companionAxisMinorInterval", {
        /**
         * Gets or sets interval of minor gridlines on the secondary axis.
        */
        get: function () {
            return this.i.py;
        },
        set: function (v) {
            this.i.py = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "companionAxisMinimumValue", {
        /**
         * Gets or sets minimum value the secondary axis.
        */
        get: function () {
            return this.i.px;
        },
        set: function (v) {
            this.i.px = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "companionAxisMaximumValue", {
        /**
         * Gets or sets maximum value the secondary axis.
        */
        get: function () {
            return this.i.pw;
        },
        set: function (v) {
            this.i.pw = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "companionAxisIsLogarithmic", {
        /**
         * Gets or sets whether or not the secondary axis is logarithmic.
        */
        get: function () {
            return this.i.o5;
        },
        set: function (v) {
            this.i.o5 = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "companionAxisLogarithmBase", {
        /**
         * Gets or sets logarithm base on the secondary axis.
        */
        get: function () {
            return this.i.qd;
        },
        set: function (v) {
            this.i.qd = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "formatAbbreviatedLabel", {
        /**
         * Sets or gets a function which takes an object that produces a formatted label for displaying in the chart.
        */
        get: function () {
            return this.i.of;
        },
        set: function (v) {
            this.i.of = v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "abbreviatedLabelFormat", {
        /**
         * Gets or sets the label format string to use for the label.
        */
        get: function () {
            return this.i.qi;
        },
        set: function (v) {
            this.i.qi = v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "abbreviatedLabelFormatSpecifiers", {
        /**
         * Gets or sets the format specifiers to use with the AbbreviatedLabelFormat string.
        */
        get: function () {
            return this.i.od;
        },
        set: function (v) {
            if (v && !Array.isArray(v) && typeof (v) == "string") {
                var re = /\s*(?:,|\s|$)\s*/gm;
                v = v.split(re);
            }
            this.i.od = v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "isFormattingAbbreviatedLargeNumber", {
        get: function () {
            return this.i.pa;
        },
        set: function (v) {
            this.i.pa = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "hasUserMinimum", {
        /**
         * Determines if the axis has a user-defined minimum.
        *
        *  `HasUserMaximum` is used to determine if a numeric axis has a user definied maximum value.
        *
        * ```ts
        * let hasSetMaximum: boolean = this.yAxis.hasUserMaximum;
        * ```
        */
        get: function () {
            return this.i.o9;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "hasUserMaximum", {
        /**
         * Determines if the axis has a user-defined maximum.
        *
        *  `HasUserMinimum` is used to determine if a numeric axis has a user definied minium value.
        *
        * ```ts
        * let hasSetMinimum: boolean = this.yAxis.hasUserMinimum;
        * ```
        */
        get: function () {
            return this.i.o8;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "abbreviateLargeNumbers", {
        /**
         * A boolean indicating whether or not to abbreviate large numbers.
        */
        get: function () {
            return this.i.o1;
        },
        set: function (v) {
            this.i.o1 = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    IgxNumericAxisBaseComponent.prototype.findByName = function (name) {
        var baseResult = _super.prototype.findByName.call(this, name);
        if (baseResult) {
            return baseResult;
        }
        if (this.abbreviatedLabelFormatSpecifiers != null && arrayFindByName(this.abbreviatedLabelFormatSpecifiers, name)) {
            return arrayFindByName(this.abbreviatedLabelFormatSpecifiers, name);
        }
        return null;
    };
    IgxNumericAxisBaseComponent.prototype.getFullRange = function () {
        var iv = this.i.ag();
        return (iv);
    };
    /**
     * Unscales a value from screen space into axis space.
    
    * @param unscaledValue  * The scaled value in screen coordinates to unscale into axis space.
    *
    * Unscales a value from screen space into axis space.
    *
    * ```ts
    * let dataValue: number = this.yAxis.unscaleValue(pixel);
    * ```
    */
    IgxNumericAxisBaseComponent.prototype.unscaleValue = function (unscaledValue) {
        var iv = this.i.p6(unscaledValue);
        return (iv);
    };
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualMinimumValueChange", {
        get: function () {
            var _this = this;
            if (this._actualMinimumValueChange == null) {
                this._actualMinimumValueChange = new EventEmitter();
                this.i.propertyChanged = delegateCombine(this.i.propertyChanged, function (o, e) {
                    var iv = e;
                    var ext = _this.actualMinimumValue;
                    if (_this.beforeActualMinimumValueChange) {
                        _this.beforeActualMinimumValueChange(_this, ext);
                    }
                    _this._actualMinimumValueChange.emit(ext);
                });
            }
            return this._actualMinimumValueChange;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualMaximumValueChange", {
        get: function () {
            var _this = this;
            if (this._actualMaximumValueChange == null) {
                this._actualMaximumValueChange = new EventEmitter();
                this.i.propertyChanged = delegateCombine(this.i.propertyChanged, function (o, e) {
                    var iv = e;
                    var ext = _this.actualMaximumValue;
                    if (_this.beforeActualMaximumValueChange) {
                        _this.beforeActualMaximumValueChange(_this, ext);
                    }
                    _this._actualMaximumValueChange.emit(ext);
                });
            }
            return this._actualMaximumValueChange;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualIntervalChange", {
        get: function () {
            var _this = this;
            if (this._actualIntervalChange == null) {
                this._actualIntervalChange = new EventEmitter();
                this.i.propertyChanged = delegateCombine(this.i.propertyChanged, function (o, e) {
                    var iv = e;
                    var ext = _this.actualInterval;
                    if (_this.beforeActualIntervalChange) {
                        _this.beforeActualIntervalChange(_this, ext);
                    }
                    _this._actualIntervalChange.emit(ext);
                });
            }
            return this._actualIntervalChange;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxNumericAxisBaseComponent.prototype, "actualMinorIntervalChange", {
        get: function () {
            var _this = this;
            if (this._actualMinorIntervalChange == null) {
                this._actualMinorIntervalChange = new EventEmitter();
                this.i.propertyChanged = delegateCombine(this.i.propertyChanged, function (o, e) {
                    var iv = e;
                    var ext = _this.actualMinorInterval;
                    if (_this.beforeActualMinorIntervalChange) {
                        _this.beforeActualMinorIntervalChange(_this, ext);
                    }
                    _this._actualMinorIntervalChange.emit(ext);
                });
            }
            return this._actualMinorIntervalChange;
        },
        enumerable: false,
        configurable: true
    });
    IgxNumericAxisBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IgxNumericAxisBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
    IgxNumericAxisBaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: IgxNumericAxisBaseComponent, selector: "ng-component", inputs: { autoRangeBufferMode: "autoRangeBufferMode", minimumValue: "minimumValue", actualMinimumValue: "actualMinimumValue", actualVisibleMinimumValue: "actualVisibleMinimumValue", maximumValue: "maximumValue", actualMaximumValue: "actualMaximumValue", actualVisibleMaximumValue: "actualVisibleMaximumValue", interval: "interval", actualInterval: "actualInterval", actualMaxPrecision: "actualMaxPrecision", maxPrecision: "maxPrecision", shouldApplyMaxPrecisionWhenZoomed: "shouldApplyMaxPrecisionWhenZoomed", minorInterval: "minorInterval", actualMinorInterval: "actualMinorInterval", referenceValue: "referenceValue", isLogarithmic: "isLogarithmic", actualIsLogarithmic: "actualIsLogarithmic", favorLabellingScaleEnd: "favorLabellingScaleEnd", logarithmBase: "logarithmBase", companionAxisInterval: "companionAxisInterval", companionAxisMinorInterval: "companionAxisMinorInterval", companionAxisMinimumValue: "companionAxisMinimumValue", companionAxisMaximumValue: "companionAxisMaximumValue", companionAxisIsLogarithmic: "companionAxisIsLogarithmic", companionAxisLogarithmBase: "companionAxisLogarithmBase", formatAbbreviatedLabel: "formatAbbreviatedLabel", abbreviatedLabelFormat: "abbreviatedLabelFormat", abbreviatedLabelFormatSpecifiers: "abbreviatedLabelFormatSpecifiers", isFormattingAbbreviatedLargeNumber: "isFormattingAbbreviatedLargeNumber", abbreviateLargeNumbers: "abbreviateLargeNumbers" }, outputs: { actualMinimumValueChange: "actualMinimumValueChange", actualMaximumValueChange: "actualMaximumValueChange", actualIntervalChange: "actualIntervalChange", actualMinorIntervalChange: "actualMinorIntervalChange" }, usesInheritance: true, ngImport: i0, template: "", isInline: true });
    return IgxNumericAxisBaseComponent;
}(IgxAxisComponent));
export { IgxNumericAxisBaseComponent };
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IgxNumericAxisBaseComponent, decorators: [{
            type: Component,
            args: [{
                    template: "",
                }]
        }], ctorParameters: function () { return []; }, propDecorators: { autoRangeBufferMode: [{
                type: Input
            }], minimumValue: [{
                type: Input
            }], actualMinimumValue: [{
                type: Input
            }], actualVisibleMinimumValue: [{
                type: Input
            }], maximumValue: [{
                type: Input
            }], actualMaximumValue: [{
                type: Input
            }], actualVisibleMaximumValue: [{
                type: Input
            }], interval: [{
                type: Input
            }], actualInterval: [{
                type: Input
            }], actualMaxPrecision: [{
                type: Input
            }], maxPrecision: [{
                type: Input
            }], shouldApplyMaxPrecisionWhenZoomed: [{
                type: Input
            }], minorInterval: [{
                type: Input
            }], actualMinorInterval: [{
                type: Input
            }], referenceValue: [{
                type: Input
            }], isLogarithmic: [{
                type: Input
            }], actualIsLogarithmic: [{
                type: Input
            }], favorLabellingScaleEnd: [{
                type: Input
            }], logarithmBase: [{
                type: Input
            }], companionAxisInterval: [{
                type: Input
            }], companionAxisMinorInterval: [{
                type: Input
            }], companionAxisMinimumValue: [{
                type: Input
            }], companionAxisMaximumValue: [{
                type: Input
            }], companionAxisIsLogarithmic: [{
                type: Input
            }], companionAxisLogarithmBase: [{
                type: Input
            }], formatAbbreviatedLabel: [{
                type: Input
            }], abbreviatedLabelFormat: [{
                type: Input
            }], abbreviatedLabelFormatSpecifiers: [{
                type: Input
            }], isFormattingAbbreviatedLargeNumber: [{
                type: Input
            }], abbreviateLargeNumbers: [{
                type: Input
            }], actualMinimumValueChange: [{
                type: Output
            }], actualMaximumValueChange: [{
                type: Output
            }], actualIntervalChange: [{
                type: Output
            }], actualMinorIntervalChange: [{
                type: Output
            }] } });
