/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { DomainChart } from "./DomainChart";
import { fromEnum, enumGetBox, markType } from "igniteui-angular-core";
import { HorizontalAlignment_$type } from "igniteui-angular-core";
import { VerticalAlignment_$type } from "igniteui-angular-core";
import { Visibility_$type } from "igniteui-angular-core";
import { ValueAxisLabelLocation_$type } from "./ValueAxisLabelLocation";
import { AngleAxisLabelLocation_$type } from "./AngleAxisLabelLocation";
import { AxisLabelSettings } from "./AxisLabelSettings";
import { AxisDefaults } from "./AxisDefaults";
import { TitleSettings } from "./TitleSettings";
import { ScalerParams } from "./ScalerParams";
import { DeviceUtils } from "igniteui-angular-core";
/**
 * @hidden
 */
export let RadialBaseChart = /*@__PURE__*/ (() => {
    class RadialBaseChart extends DomainChart {
        constructor() {
            super(...arguments);
            this.aa3 = null;
            this.aa4 = null;
            this.abi = 0;
            this.abk = 5;
            this.abj = 0;
            this.abh = 5;
            this.ab1 = 5;
            this.ab3 = 0;
            this.ab2 = 5;
            this.ab0 = 0;
            this.ag4 = null;
            this.ahb = null;
            this.ag2 = null;
            this.ag3 = null;
            this.abv = 0;
            this.ace = 0;
            this.abu = NaN;
            this.acd = NaN;
            this.abx = NaN;
            this.acg = NaN;
            this.abw = NaN;
            this.acf = NaN;
            this.abt = NaN;
            this.acc = NaN;
            this.aha = null;
            this.ahh = null;
            this.ads = null;
            this.adw = null;
            this.adu = null;
            this.ady = null;
            this.adn = null;
            this.ado = null;
            this.ag5 = null;
            this.ahc = null;
            this.abl = DeviceUtils.g(1);
            this.ab4 = DeviceUtils.g(1);
            this.abo = DeviceUtils.g(1);
            this.ab7 = DeviceUtils.g(1);
            this.ag7 = null;
            this.ahe = null;
            this.ag8 = null;
            this.ahf = null;
            this.abp = DeviceUtils.g(1);
            this.ab8 = DeviceUtils.g(1);
            this.abq = DeviceUtils.g(8);
            this.ab9 = 0;
            this.ag9 = null;
            this.ahg = null;
            this.abr = DeviceUtils.g(1);
            this.aca = DeviceUtils.g(1);
            this.adt = null;
            this.adx = null;
            this.ag6 = null;
            this.ahd = null;
            this.abg = 0;
            this.abz = 0;
            this.abf = NaN;
            this.abm = NaN;
            this.abn = NaN;
            this.aby = NaN;
            this.ab5 = NaN;
            this.ab6 = NaN;
            this.abs = 0;
            this.acb = -90;
            this.abb = false;
            this.abc = false;
            this.agx = 1;
            this.ah0 = 1;
            this.agw = 1;
            this.agy = 2;
            this.ahy = 0;
            this.ahz = 1;
            this.ah4 = 0;
            this.ah5 = 0;
            this.aa9 = 4;
            this.aaz = 4;
            this.adr = null;
            this.aav = null;
            this.adv = null;
            this.aaw = null;
        }
        provideContainer(a) {
            if (a != null) {
                let b = this.aa1();
                let c = this.aa2();
                if (b != null) {
                    b.provideRenderer(a);
                }
                if (c != null) {
                    c.provideRenderer(a);
                }
            }
            super.provideContainer(a);
        }
        vw() {
            super.vw();
            let a = this.aa1();
            let b = this.aa2();
            if (a != null && a.a3 != null) {
                this.ahk = a.a3.textColor;
            }
            if (b != null && b.a3 != null) {
                this.ahr = b.a3.textColor;
            }
            this.ahp = AxisDefaults.axis_TickBrush;
            this.ahw = AxisDefaults.axis_TickBrush;
            this.ahl = AxisDefaults.axis_MajorBrush;
            this.ahs = AxisDefaults.axis_MajorBrush;
            this.aho = AxisDefaults.axis_LineBrush;
            this.ahv = AxisDefaults.axis_LineBrush;
        }
        wr(a, b, c) {
            super.wr(a, b, c);
            switch (a) {
                case "AngleAxisLabelLeftMargin":
                    this.ago((d) => d.leftMargin = this.ack);
                    break;
                case "AngleAxisLabelTopMargin":
                    this.ago((d) => d.topMargin = this.acm);
                    break;
                case "AngleAxisLabelRightMargin":
                    this.ago((d) => d.rightMargin = this.acl);
                    break;
                case "AngleAxisLabelBottomMargin":
                    this.ago((d) => d.bottomMargin = this.acj);
                    break;
                case "ValueAxisLabelLeftMargin":
                    this.agt((d) => d.leftMargin = this.ac7);
                    break;
                case "ValueAxisLabelTopMargin":
                    this.agt((d) => d.topMargin = this.ac9);
                    break;
                case "ValueAxisLabelRightMargin":
                    this.agt((d) => d.rightMargin = this.ac8);
                    break;
                case "ValueAxisLabelBottomMargin":
                    this.agt((d) => d.bottomMargin = this.ac6);
                    break;
                case "ActualItemsSource":
                case "ShouldDisplayMockData":
                case "ShouldUseSkeletonStyleForMockData":
                    this.ahi = this.zt(this.ahk);
                    this.ahj = this.zt(this.ahr);
                    break;
                case "AngleAxisLabelTextColor":
                    this.ahi = this.zt(this.ahk);
                    break;
                case "ValueAxisLabelTextColor":
                    this.ahj = this.zt(this.ahr);
                    break;
                case "ActualAngleAxisLabelTextColor":
                    this.ago((d) => d.textColor = this.ahi);
                    break;
                case "ActualValueAxisLabelTextColor":
                    this.agt((d) => d.textColor = this.ahj);
                    break;
                case "AngleAxisTitleMargin":
                    this.agq((d) => d.margin = this.acx);
                    break;
                case "ValueAxisTitleMargin":
                    this.agv((d) => d.margin = this.adk);
                    break;
                case "AngleAxisTitleLeftMargin":
                    this.agq((d) => d.leftMargin = this.acw);
                    break;
                case "ValueAxisTitleLeftMargin":
                    this.agv((d) => d.leftMargin = this.adj);
                    break;
                case "AngleAxisTitleTopMargin":
                    this.agq((d) => d.topMargin = this.acz);
                    break;
                case "ValueAxisTitleTopMargin":
                    this.agv((d) => d.topMargin = this.adm);
                    break;
                case "AngleAxisTitleRightMargin":
                    this.agq((d) => d.rightMargin = this.acy);
                    break;
                case "ValueAxisTitleRightMargin":
                    this.agv((d) => d.rightMargin = this.adl);
                    break;
                case "AngleAxisTitleBottomMargin":
                    this.agq((d) => d.bottomMargin = this.acv);
                    break;
                case "ValueAxisTitleBottomMargin":
                    this.agv((d) => d.bottomMargin = this.adi);
                    break;
                case "AngleAxisTitleTextColor":
                    this.agq((d) => d.textColor = this.ahq);
                    break;
                case "ValueAxisTitleTextColor":
                    this.agv((d) => d.textColor = this.ahx);
                    break;
                case "AngleAxisFormatLabel":
                    this.agm((d) => d.ay = this.aa5);
                    break;
                case "ValueAxisFormatLabel":
                    this.agr((d) => d.ay = this.aa6);
                    break;
            }
        }
        get aa5() {
            return this.aa3;
        }
        set aa5(a) {
            let b = this.aa5;
            if (a != b) {
                this.aa3 = a;
                this.wn("AngleAxisFormatLabel", b, this.aa5);
            }
        }
        get aa6() {
            return this.aa4;
        }
        set aa6(a) {
            let b = this.aa6;
            if (a != b) {
                this.aa4 = a;
                this.wn("ValueAxisFormatLabel", b, this.aa6);
            }
        }
        get ack() {
            return this.abi;
        }
        set ack(a) {
            let b = this.ack;
            if (a != b) {
                this.abi = a;
                this.wn("AngleAxisLabelLeftMargin", b, this.ack);
            }
        }
        get acm() {
            return this.abk;
        }
        set acm(a) {
            let b = this.acm;
            if (a != b) {
                this.abk = a;
                this.wn("AngleAxisLabelTopMargin", b, this.acm);
            }
        }
        get acl() {
            return this.abj;
        }
        set acl(a) {
            let b = this.acl;
            if (a != b) {
                this.abj = a;
                this.wn("AngleAxisLabelRightMargin", b, this.acl);
            }
        }
        get acj() {
            return this.abh;
        }
        set acj(a) {
            let b = this.acj;
            if (a != b) {
                this.abh = a;
                this.wn("AngleAxisLabelBottomMargin", b, this.acj);
            }
        }
        get ac7() {
            return this.ab1;
        }
        set ac7(a) {
            let b = this.ac7;
            if (a != b) {
                this.ab1 = a;
                this.wn("ValueAxisLabelLeftMargin", b, this.ac7);
            }
        }
        get ac9() {
            return this.ab3;
        }
        set ac9(a) {
            let b = this.ac9;
            if (a != b) {
                this.ab3 = a;
                this.wn("ValueAxisLabelTopMargin", b, this.ac9);
            }
        }
        get ac8() {
            return this.ab2;
        }
        set ac8(a) {
            let b = this.ac8;
            if (a != b) {
                this.ab2 = a;
                this.wn("ValueAxisLabelRightMargin", b, this.ac8);
            }
        }
        get ac6() {
            return this.ab0;
        }
        set ac6(a) {
            let b = this.ac6;
            if (a != b) {
                this.ab0 = a;
                this.wn("ValueAxisLabelBottomMargin", b, this.ac6);
            }
        }
        get ahk() {
            return this.ag4;
        }
        set ahk(a) {
            let b = this.ahk;
            if (a != b) {
                this.ag4 = a;
                this.wn("AngleAxisLabelTextColor", b, this.ahk);
            }
        }
        get ahr() {
            return this.ahb;
        }
        set ahr(a) {
            let b = this.ahr;
            if (a != b) {
                this.ahb = a;
                this.wn("ValueAxisLabelTextColor", b, this.ahr);
            }
        }
        get ahi() {
            return this.ag2;
        }
        set ahi(a) {
            let b = this.ag2;
            if (a != b) {
                this.ag2 = a;
                this.wn("ActualAngleAxisLabelTextColor", b, this.ahi);
            }
        }
        get ahj() {
            return this.ag3;
        }
        set ahj(a) {
            let b = this.ag3;
            if (a != b) {
                this.ag3 = a;
                this.wn("ActualValueAxisLabelTextColor", b, this.ahj);
            }
        }
        get acx() {
            return this.abv;
        }
        set acx(a) {
            let b = this.acx;
            if (a != b) {
                this.abv = a;
                this.wn("AngleAxisTitleMargin", b, this.acx);
            }
        }
        get adk() {
            return this.ace;
        }
        set adk(a) {
            let b = this.adk;
            if (a != b) {
                this.ace = a;
                this.wn("ValueAxisTitleMargin", b, this.adk);
            }
        }
        get acw() {
            return this.abu;
        }
        set acw(a) {
            let b = this.acw;
            if (a != b) {
                this.abu = a;
                this.wn("AngleAxisTitleLeftMargin", b, this.acw);
            }
        }
        get adj() {
            return this.acd;
        }
        set adj(a) {
            let b = this.adj;
            if (a != b) {
                this.acd = a;
                this.wn("ValueAxisTitleLeftMargin", b, this.adj);
            }
        }
        get acz() {
            return this.abx;
        }
        set acz(a) {
            let b = this.acz;
            if (a != b) {
                this.abx = a;
                this.wn("AngleAxisTitleTopMargin", b, this.acz);
            }
        }
        get adm() {
            return this.acg;
        }
        set adm(a) {
            let b = this.adm;
            if (a != b) {
                this.acg = a;
                this.wn("ValueAxisTitleTopMargin", b, this.adm);
            }
        }
        get acy() {
            return this.abw;
        }
        set acy(a) {
            let b = this.acy;
            if (a != b) {
                this.abw = a;
                this.wn("AngleAxisTitleRightMargin", b, this.acy);
            }
        }
        get adl() {
            return this.acf;
        }
        set adl(a) {
            let b = this.adl;
            if (a != b) {
                this.acf = a;
                this.wn("ValueAxisTitleRightMargin", b, this.adl);
            }
        }
        get acv() {
            return this.abt;
        }
        set acv(a) {
            let b = this.acv;
            if (a != b) {
                this.abt = a;
                this.wn("AngleAxisTitleBottomMargin", b, this.acv);
            }
        }
        get adi() {
            return this.acc;
        }
        set adi(a) {
            let b = this.adi;
            if (a != b) {
                this.acc = a;
                this.wn("ValueAxisTitleBottomMargin", b, this.adi);
            }
        }
        get ahq() {
            return this.aha;
        }
        set ahq(a) {
            let b = this.ahq;
            if (a != b) {
                this.aha = a;
                this.wn("AngleAxisTitleTextColor", b, this.ahq);
            }
        }
        get ahx() {
            return this.ahh;
        }
        set ahx(a) {
            let b = this.ahx;
            if (a != b) {
                this.ahh = a;
                this.wn("ValueAxisTitleTextColor", b, this.ahx);
            }
        }
        ws(a, b, c) {
            super.ws(a, b, c);
            switch (a) {
                case "AngleAxisLabelTextStyle":
                    this.ago((d) => d.textStyle = this.aef);
                    break;
                case "ValueAxisLabelTextStyle":
                    this.agt((d) => d.textStyle = this.afn);
                    break;
                case "AngleAxisTitleTextStyle":
                    this.agq((d) => d.textStyle = this.ae5);
                    break;
                case "ValueAxisTitleTextStyle":
                    this.agv((d) => d.textStyle = this.agd);
                    break;
            }
        }
        get aef() {
            return this.ads;
        }
        set aef(a) {
            let b = this.aef;
            if (a != b) {
                this.ads = a;
                this.wn("AngleAxisLabelTextStyle", b, this.aef);
            }
        }
        get afn() {
            return this.adw;
        }
        set afn(a) {
            let b = this.afn;
            if (a != b) {
                this.adw = a;
                this.wn("ValueAxisLabelTextStyle", b, this.afn);
            }
        }
        get ae5() {
            return this.adu;
        }
        set ae5(a) {
            let b = this.ae5;
            if (a != b) {
                this.adu = a;
                this.wn("AngleAxisTitleTextStyle", b, this.ae5);
            }
        }
        get agd() {
            return this.ady;
        }
        set agd(a) {
            let b = this.agd;
            if (a != b) {
                this.ady = a;
                this.wn("ValueAxisTitleTextStyle", b, this.agd);
            }
        }
        agj(a) {
            this.agg(a, (b) => b.leftMargin = this.ack);
            this.agg(a, (b) => b.topMargin = this.acm);
            this.agg(a, (b) => b.rightMargin = this.acl);
            this.agg(a, (b) => b.bottomMargin = this.acj);
            this.agg(a, (b) => b.textColor = this.ahi);
            this.agh(a, (b) => b.textColor = this.ahq);
            this.agh(a, (b) => b.leftMargin = this.acw);
            this.agh(a, (b) => b.topMargin = this.acz);
            this.agh(a, (b) => b.rightMargin = this.acy);
            this.agh(a, (b) => b.bottomMargin = this.acv);
            this.agg(a, (b) => b.textStyle = this.aef);
            this.agh(a, (b) => b.textStyle = this.ae5);
        }
        agl(a) {
            this.agg(a, (b) => b.leftMargin = this.ac7);
            this.agg(a, (b) => b.topMargin = this.ac9);
            this.agg(a, (b) => b.rightMargin = this.ac8);
            this.agg(a, (b) => b.bottomMargin = this.ac6);
            this.agg(a, (b) => b.textColor = this.ahj);
            this.agh(a, (b) => b.textColor = this.ahx);
            this.agh(a, (b) => b.leftMargin = this.adj);
            this.agh(a, (b) => b.topMargin = this.adm);
            this.agh(a, (b) => b.rightMargin = this.adl);
            this.agh(a, (b) => b.bottomMargin = this.adi);
            this.agg(a, (b) => b.textStyle = this.afn);
            this.agh(a, (b) => b.textStyle = this.agd);
        }
        xk(a) {
            let b = this.bf(a);
            let c = this.dd(a, b);
            if (c == null) {
                return;
            }
            c.itemsSource = this.ib(a);
            if (a.highlightedData != null) {
                c.highlightedItemsSource = this.ic(a);
            }
            c.name = this.q9(a);
            c.title = this.ra(a, b);
            this.dataChart.series.add(c);
        }
        agm(a) {
            this.agn(a, null);
        }
        agn(a, b) {
            a(this.aa1());
        }
        ags(a, b) {
            a(this.aa2());
        }
        agr(a) {
            this.ags(a, true);
        }
        vf(a, b) {
            this.agm(a);
            this.ags(a, b);
        }
        agq(a) {
            this.agh(this.aa1(), a);
        }
        agv(a) {
            this.agh(this.aa2(), a);
        }
        agt(a) {
            this.agg(this.aa2(), a);
        }
        ago(a) {
            this.agg(this.aa1(), a);
        }
        ac0(a) {
            let b = this.aa1();
            return b.ft(a, new ScalerParams(1, this.z2, this.z1, b.df));
        }
        ac2(a) {
            let b = this.aa1();
            return b.fw(a, new ScalerParams(1, this.z2, this.z1, b.df));
        }
        ac1(a) {
            let b = this.aa2();
            return b.ft(a, new ScalerParams(1, this.z2, this.z1, b.df));
        }
        ac3(a) {
            let b = this.aa2();
            return b.fw(a, new ScalerParams(1, this.z2, this.z1, b.df));
        }
        xh(a) {
            super.xh(a);
            if (a == null) {
                return;
            }
            if (a.axes != null) {
                let b = this.aa1();
                let c = this.aa2();
                if (a.axes.contains(b)) {
                    a.axes.remove(b);
                }
                if (a.axes.contains(c)) {
                    a.axes.remove(c);
                }
            }
        }
        static ae8(a, b) {
            for (let c of fromEnum(b)) {
                let d = c.findMatchingHint(16);
                if (d != null) {
                    let e = d.path;
                    return e;
                }
            }
            return null;
        }
        vr(a, b) {
            super.vr(a, b);
            if (a == this.dataChart) {
                this.dataChart.axes.add(this.aa1());
                this.dataChart.axes.add(this.aa2());
            }
        }
        agi(a) {
            if (a != null && this.mb != null && a.gx == null) {
                a.provideRenderer(this.mb);
            }
            a.ni = this.ahl;
            a.f1 = this.acn;
            a.nj = this.ahm;
            a.f4 = this.acq;
            a.nm = this.aho;
            a.gs = this.acr;
            a.nl = this.ahn;
            a.gt = this.acs;
            a.nn = this.ahp;
            a.gu = this.act;
            a.d5 = true;
            a.dv = this.shouldAvoidAxisAnnotationCollisions;
            a.dx = this.shouldAvoidAxisAnnotationCollisions;
            let b = a == this.aa1();
            if (b) {
                a.jb = this.aew;
            }
            a.hg = this.adp;
            a.ik = this.ad6;
            a.ah = this.aax;
            this.agg(a, (c) => c.angle = this.aci);
            this.agg(a, (c) => {
                if (c.extent != this.ach) {
                    c.extent = this.ach;
                }
            });
            this.agg(a, (c) => {
                if (c.maximumExtent != this.aco) {
                    c.maximumExtent = this.aco;
                }
            });
            this.agg(a, (c) => {
                if (c.maximumExtentPercentage != this.acp) {
                    c.maximumExtentPercentage = this.acp;
                }
            });
            this.agg(a, (c) => c.horizontalAlignment = this.agz);
            this.agg(a, (c) => c.verticalAlignment = this.ah1);
            this.agg(a, (c) => c.visibility = this.ah6);
            this.agg(a, (c) => c.location = this.aa7(this.aa0));
            this.agh(a, (c) => c.horizontalAlignment = this.ag0);
            this.agh(a, (c) => c.angle = this.acu);
            this.agj(a);
        }
        agk(a) {
            if (a == null) {
                return;
            }
            if (this.mb != null && a.gx == null) {
                a.provideRenderer(this.mb);
            }
            a.dv = this.shouldAvoidAxisAnnotationCollisions;
            a.dx = this.shouldAvoidAxisAnnotationCollisions;
            this.agg(a, (b) => b.angle = this.ac5);
            this.agg(a, (b) => {
                if (b.extent != this.ac4) {
                    b.extent = this.ac4;
                }
            });
            this.agg(a, (b) => {
                if (b.maximumExtent != this.adb) {
                    b.maximumExtent = this.adb;
                }
            });
            this.agg(a, (b) => {
                if (b.maximumExtentPercentage != this.adc) {
                    b.maximumExtentPercentage = this.adc;
                }
            });
            this.agg(a, (b) => b.horizontalAlignment = this.ag1);
            this.agg(a, (b) => b.verticalAlignment = this.ah2);
            this.agg(a, (b) => b.visibility = this.ah7);
            this.agg(a, (b) => b.location = this.aa8(this.aba));
            this.agh(a, (b) => b.verticalAlignment = this.ah3);
            this.agh(a, (b) => b.angle = this.adh);
            a.ni = this.ahs;
            a.f1 = this.ada;
            a.nj = this.aht;
            a.f4 = this.add;
            a.nm = this.ahv;
            a.gs = this.ade;
            a.nl = this.ahu;
            a.gt = this.adf;
            a.nn = this.ahw;
            a.gu = this.adg;
            let b = a == this.aa2();
            if (b) {
                a.jb = this.af4;
            }
            a.ik = this.afe;
            a.ah = this.aay;
            this.agl(a);
        }
        vo() {
            super.vo();
            this.agi(this.aa1());
            this.agk(this.aa2());
        }
        agg(a, b) {
            if (a == null) {
                return;
            }
            if (a.a3 == null) {
                a.a3 = new AxisLabelSettings();
                a.a3.angle = a.ff();
                a.a3.bottomMargin = a.fg();
                a.a3.leftMargin = a.fh();
                a.a3.rightMargin = a.fi();
                a.a3.topMargin = a.fj();
                a.a3.horizontalAlignment = a.m7();
                a.a3.location = a.a5();
                a.a3.verticalAlignment = a.n9();
            }
            b(a.a3);
        }
        agh(a, b) {
            if (a == null) {
                return;
            }
            if (a.bx == null) {
                a.bx = new TitleSettings();
                a.bx.bottomMargin = a.fl();
                a.bx.leftMargin = a.fm();
                a.bx.rightMargin = a.fn();
                a.bx.topMargin = a.fo();
                a.bx.location = a.a6();
                a.bx.angle = a.fk();
                a.bx.horizontalAlignment = a.m8();
                a.bx.verticalAlignment = a.oa();
            }
            b(a.bx);
        }
        wn(a, b, c) {
            super.wn(a, b, c);
            switch (a) {
                case "AngleAxisLabelAngle":
                    this.ago((d) => d.angle = this.aci);
                    break;
                case "ValueAxisLabelAngle":
                    this.agt((d) => d.angle = this.ac5);
                    break;
                case "AngleAxisLabelHorizontalAlignment":
                    this.ago((d) => d.horizontalAlignment = this.agz);
                    break;
                case "ValueAxisLabelHorizontalAlignment":
                    this.agt((d) => d.horizontalAlignment = this.ag1);
                    break;
                case "AngleAxisLabelVerticalAlignment":
                    this.ago((d) => d.verticalAlignment = this.ah1);
                    break;
                case "ValueAxisLabelVerticalAlignment":
                    this.agt((d) => d.verticalAlignment = this.ah2);
                    break;
                case "AngleAxisLabelVisibility":
                    this.ago((d) => d.visibility = this.ah6);
                    break;
                case "ValueAxisLabelVisibility":
                    this.agt((d) => d.visibility = this.ah7);
                    break;
                case "AngleAxisLabel":
                    this.agm((d) => d.hg = this.adp);
                    break;
                case "ValueAxisLabel":
                    this.agr((d) => d.hg = this.adq);
                    break;
                case "AngleAxisLabelFormat":
                    this.agm((d) => d.ik = this.ad6);
                    break;
                case "AngleAxisLabelFormatSpecifiers":
                    this.agm((d) => d.ah = this.aax);
                    break;
                case "ValueAxisLabelFormat":
                    this.agr((d) => d.ik = this.afe);
                    break;
                case "ValueAxisLabelFormatSpecifiers":
                    this.agr((d) => d.ah = this.aay);
                    break;
                case "AngleAxisTitleAngle":
                    this.agq((d) => d.angle = this.acu);
                    break;
                case "ValueAxisTitleAngle":
                    this.agv((d) => d.angle = this.adh);
                    break;
                case "AngleAxisTitleAlignment":
                    this.agq((d) => d.horizontalAlignment = this.ag0);
                    break;
                case "ValueAxisTitleAlignment":
                    this.agv((d) => d.verticalAlignment = this.ah3);
                    break;
                case "AngleAxisTitle":
                    this.agm((d) => d.jb = this.aew);
                    break;
                case "ValueAxisTitle":
                    this.ags((d) => d.jb = this.af4, false);
                    break;
                case "AngleAxisMajorStroke":
                    this.agn((d) => d.ni = this.ahl, a);
                    break;
                case "ValueAxisMajorStroke":
                    this.agr((d) => d.ni = this.ahs);
                    break;
                case "AngleAxisMajorStrokeThickness":
                    this.agn((d) => d.f1 = this.acn, a);
                    break;
                case "ValueAxisMajorStrokeThickness":
                    this.agr((d) => d.f1 = this.ada);
                    break;
                case "AngleAxisMinorStroke":
                    this.agm((d) => d.nj = this.ahm);
                    break;
                case "ValueAxisMinorStroke":
                    this.agr((d) => d.nj = this.aht);
                    break;
                case "AngleAxisMinorStrokeThickness":
                    this.agm((d) => d.f4 = this.acq);
                    break;
                case "ValueAxisMinorStrokeThickness":
                    this.agr((d) => d.f4 = this.add);
                    break;
                case "AngleAxisTickLength":
                    this.agm((d) => d.gt = this.acs);
                    break;
                case "ValueAxisTickLength":
                    this.agr((d) => d.gt = this.adf);
                    break;
                case "AngleAxisTickStroke":
                    this.agm((d) => d.nn = this.ahp);
                    break;
                case "ValueAxisTickStroke":
                    this.agr((d) => d.nn = this.ahw);
                    break;
                case "AngleAxisTickStrokeThickness":
                    this.agm((d) => d.gu = this.act);
                    break;
                case "ValueAxisTickStrokeThickness":
                    this.agr((d) => d.gu = this.adg);
                    break;
                case "AngleAxisStroke":
                    this.agm((d) => d.nm = this.aho);
                    break;
                case "ValueAxisStroke":
                    this.agr((d) => d.nm = this.ahv);
                    break;
                case "AngleAxisStrokeThickness":
                    this.agm((d) => d.gs = this.acr);
                    break;
                case "ValueAxisStrokeThickness":
                    this.agr((d) => d.gs = this.ade);
                    break;
                case "AngleAxisExtent":
                    this.ago((d) => d.extent = this.ach);
                    break;
                case "AngleAxisMaximumExtent":
                    this.ago((d) => d.maximumExtent = this.aco);
                    break;
                case "AngleAxisMaximumExtentPercentage":
                    this.ago((d) => d.maximumExtentPercentage = this.acp);
                    break;
                case "ValueAxisExtent":
                    this.agt((d) => d.extent = this.ac4);
                    break;
                case "ValueAxisMaximumExtent":
                    this.agt((d) => d.maximumExtent = this.aco);
                    break;
                case "ValueAxisMaximumExtentPercentage":
                    this.agt((d) => d.maximumExtentPercentage = this.acp);
                    break;
                case "AngleAxisStrip":
                    this.agm((d) => d.nl = this.ahn);
                    break;
                case "ValueAxisStrip":
                    this.agr((d) => d.nl = this.ahu);
                    break;
                case "AngleAxisInverted":
                    this.agm((d) => d.df = this.abd);
                    break;
                case "ValueAxisInverted":
                    this.agr((d) => d.df = this.abe);
                    break;
                case "ValueAxisLabelLocation":
                    this.agu();
                    break;
                case "AngleAxisLabelLocation":
                    this.agp();
                    break;
            }
        }
        agu() {
            let a = this.aa8(this.aba);
            if (a == 2 || a == 7) {
                this.ag1 = 2;
            }
            else {
                this.ag1 = 0;
            }
            this.agt((b) => b.location = a);
        }
        agp() {
            let a = this.aa7(this.aa0);
            if (a == 1 || a == 5) {
                this.ah1 = 0;
            }
            else {
                this.ah1 = 2;
            }
            this.ago((b) => b.location = a);
        }
        aa8(a) {
            if (a == 0) {
                return 2;
            }
            else if (a == 1) {
                return 3;
            }
            else if (a == 3) {
                return 7;
            }
            else if (a == 2) {
                return 6;
            }
            else {
                if (this.cc == 1) {
                    return 3;
                }
                else {
                    return 2;
                }
            }
        }
        aa7(a) {
            if (a == 1) {
                return 1;
            }
            else if (a == 0) {
                return 0;
            }
            else if (a == 3) {
                return 5;
            }
            else if (a == 2) {
                return 4;
            }
            else {
                return 1;
            }
        }
        get adp() {
            return this.adn;
        }
        set adp(a) {
            let b = this.adp;
            if (a != b) {
                this.adn = a;
                this.wn("AngleAxisLabel", b, this.adp);
            }
        }
        get adq() {
            return this.ado;
        }
        set adq(a) {
            let b = this.adq;
            if (a != b) {
                this.ado = a;
                this.wn("ValueAxisLabel", b, this.adq);
            }
        }
        get ahl() {
            return this.ag5;
        }
        set ahl(a) {
            let b = this.ahl;
            if (a != b) {
                this.ag5 = a;
                this.wn("AngleAxisMajorStroke", b, this.ahl);
            }
        }
        get ahs() {
            return this.ahc;
        }
        set ahs(a) {
            let b = this.ahs;
            if (a != b) {
                this.ahc = a;
                this.wn("ValueAxisMajorStroke", b, this.ahs);
            }
        }
        get acn() {
            return this.abl;
        }
        set acn(a) {
            let b = this.acn;
            if (a != b) {
                this.abl = a;
                this.wn("AngleAxisMajorStrokeThickness", b, this.acn);
            }
        }
        get ada() {
            return this.ab4;
        }
        set ada(a) {
            let b = this.ada;
            if (a != b) {
                this.ab4 = a;
                this.wn("ValueAxisMajorStrokeThickness", b, this.ada);
            }
        }
        get acq() {
            return this.abo;
        }
        set acq(a) {
            let b = this.acq;
            if (a != b) {
                this.abo = a;
                this.wn("AngleAxisMinorStrokeThickness", b, this.acq);
            }
        }
        get add() {
            return this.ab7;
        }
        set add(a) {
            let b = this.add;
            if (a != b) {
                this.ab7 = a;
                this.wn("ValueAxisMinorStrokeThickness", b, this.add);
            }
        }
        get ahn() {
            return this.ag7;
        }
        set ahn(a) {
            let b = this.ahn;
            if (a != b) {
                this.ag7 = a;
                this.wn("AngleAxisStrip", b, this.ahn);
            }
        }
        get ahu() {
            return this.ahe;
        }
        set ahu(a) {
            let b = this.ahu;
            if (a != b) {
                this.ahe = a;
                this.wn("ValueAxisStrip", b, this.ahu);
            }
        }
        get aho() {
            return this.ag8;
        }
        set aho(a) {
            let b = this.aho;
            if (a != b) {
                this.ag8 = a;
                this.wn("AngleAxisStroke", b, this.aho);
            }
        }
        get ahv() {
            return this.ahf;
        }
        set ahv(a) {
            let b = this.ahv;
            if (a != b) {
                this.ahf = a;
                this.wn("ValueAxisStroke", b, this.ahv);
            }
        }
        get acr() {
            return this.abp;
        }
        set acr(a) {
            let b = this.acr;
            if (a != b) {
                this.abp = a;
                this.wn("AngleAxisStrokeThickness", b, this.acr);
            }
        }
        get ade() {
            return this.ab8;
        }
        set ade(a) {
            let b = this.ade;
            if (a != b) {
                this.ab8 = a;
                this.wn("ValueAxisStrokeThickness", b, this.ade);
            }
        }
        get acs() {
            return this.abq;
        }
        set acs(a) {
            let b = this.acs;
            if (a != b) {
                this.abq = a;
                this.wn("AngleAxisTickLength", b, this.acs);
            }
        }
        get adf() {
            return this.ab9;
        }
        set adf(a) {
            let b = this.adf;
            if (a != b) {
                this.ab9 = a;
                this.wn("ValueAxisTickLength", b, this.adf);
            }
        }
        get ahp() {
            return this.ag9;
        }
        set ahp(a) {
            let b = this.ahp;
            if (a != b) {
                this.ag9 = a;
                this.wn("AngleAxisTickStroke", b, this.ahp);
            }
        }
        get ahw() {
            return this.ahg;
        }
        set ahw(a) {
            let b = this.ahw;
            if (a != b) {
                this.ahg = a;
                this.wn("ValueAxisTickStroke", b, this.ahw);
            }
        }
        get act() {
            return this.abr;
        }
        set act(a) {
            let b = this.act;
            if (a != b) {
                this.abr = a;
                this.wn("AngleAxisTickStrokeThickness", b, this.act);
            }
        }
        get adg() {
            return this.aca;
        }
        set adg(a) {
            let b = this.adg;
            if (a != b) {
                this.aca = a;
                this.wn("ValueAxisTickStrokeThickness", b, this.adg);
            }
        }
        get aew() {
            return this.adt;
        }
        set aew(a) {
            let b = this.aew;
            if (a != b) {
                this.adt = a;
                this.wn("AngleAxisTitle", b, this.aew);
            }
        }
        get af4() {
            return this.adx;
        }
        set af4(a) {
            let b = this.af4;
            if (a != b) {
                this.adx = a;
                this.wn("ValueAxisTitle", b, this.af4);
            }
        }
        get ahm() {
            return this.ag6;
        }
        set ahm(a) {
            let b = this.ahm;
            if (a != b) {
                this.ag6 = a;
                this.wn("AngleAxisMinorStroke", b, this.ahm);
            }
        }
        get aht() {
            return this.ahd;
        }
        set aht(a) {
            let b = this.aht;
            if (a != b) {
                this.ahd = a;
                this.wn("ValueAxisMinorStroke", b, this.aht);
            }
        }
        get aci() {
            return this.abg;
        }
        set aci(a) {
            let b = this.aci;
            if (a != b) {
                this.abg = a;
                this.wn("AngleAxisLabelAngle", b, this.aci);
            }
        }
        get ac5() {
            return this.abz;
        }
        set ac5(a) {
            let b = this.ac5;
            if (a != b) {
                this.abz = a;
                this.wn("ValueAxisLabelAngle", b, this.ac5);
            }
        }
        get ach() {
            return this.abf;
        }
        set ach(a) {
            let b = this.ach;
            if (a != b) {
                this.abf = a;
                this.wn("AngleAxisExtent", b, this.ach);
            }
        }
        get aco() {
            return this.abm;
        }
        set aco(a) {
            let b = this.aco;
            if (a != b) {
                this.abm = a;
                this.wn("AngleAxisMaximumExtent", b, this.aco);
            }
        }
        get acp() {
            return this.abn;
        }
        set acp(a) {
            let b = this.acp;
            if (a != b) {
                this.abn = a;
                this.wn("AngleAxisMaximumExtentPercentage", b, this.acp);
            }
        }
        get ac4() {
            return this.aby;
        }
        set ac4(a) {
            let b = this.ac4;
            if (a != b) {
                this.aby = a;
                this.wn("ValueAxisExtent", b, this.ac4);
            }
        }
        get adb() {
            return this.ab5;
        }
        set adb(a) {
            let b = this.adb;
            if (a != b) {
                this.ab5 = a;
                this.wn("ValueAxisMaximumExtent", b, this.adb);
            }
        }
        get adc() {
            return this.ab6;
        }
        set adc(a) {
            let b = this.adc;
            if (a != b) {
                this.ab6 = a;
                this.wn("ValueAxisMaximumExtentPercentage", b, this.adc);
            }
        }
        get acu() {
            return this.abs;
        }
        set acu(a) {
            let b = this.acu;
            if (a != b) {
                this.abs = a;
                this.wn("AngleAxisTitleAngle", b, this.acu);
            }
        }
        get adh() {
            return this.acb;
        }
        set adh(a) {
            let b = this.adh;
            if (a != b) {
                this.acb = a;
                this.wn("ValueAxisTitleAngle", b, this.adh);
            }
        }
        get abd() {
            return this.abb;
        }
        set abd(a) {
            let b = this.abd;
            if (a != b) {
                this.abb = a;
                this.wn("AngleAxisInverted", b, this.abd);
            }
        }
        get abe() {
            return this.abc;
        }
        set abe(a) {
            let b = this.abe;
            if (a != b) {
                this.abc = a;
                this.wn("ValueAxisInverted", b, this.abe);
            }
        }
        get ag0() {
            return this.agx;
        }
        set ag0(a) {
            let b = this.ag0;
            if (a != b) {
                this.agx = a;
                this.wn("AngleAxisTitleAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.ag0));
            }
        }
        get ah3() {
            return this.ah0;
        }
        set ah3(a) {
            let b = this.ah3;
            if (a != b) {
                this.ah0 = a;
                this.wn("ValueAxisTitleAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ah3));
            }
        }
        get agz() {
            return this.agw;
        }
        set agz(a) {
            let b = this.agz;
            if (a != b) {
                this.agw = a;
                this.wn("AngleAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.agz));
            }
        }
        get_ag1() {
            return this.agy;
        }
        set_ag1(a) {
            let b = this.ag1;
            if (a != b) {
                this.agy = a;
                this.wn("ValueAxisLabelHorizontalAlignment", enumGetBox(HorizontalAlignment_$type, b), enumGetBox(HorizontalAlignment_$type, this.ag1));
            }
        }
        get ag1() {
            return this.get_ag1();
        }
        set ag1(a) {
            this.set_ag1(a);
        }
        get ah1() {
            return this.ahy;
        }
        set ah1(a) {
            let b = this.ah1;
            if (a != b) {
                this.ahy = a;
                this.wn("AngleAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ah1));
            }
        }
        get ah2() {
            return this.ahz;
        }
        set ah2(a) {
            let b = this.ah2;
            if (a != b) {
                this.ahz = a;
                this.wn("ValueAxisLabelVerticalAlignment", enumGetBox(VerticalAlignment_$type, b), enumGetBox(VerticalAlignment_$type, this.ah2));
            }
        }
        get ah6() {
            return this.ah4;
        }
        set ah6(a) {
            let b = this.ah6;
            if (a != b) {
                this.ah4 = a;
                this.wn("AngleAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ah6));
            }
        }
        get ah7() {
            return this.ah5;
        }
        set ah7(a) {
            let b = this.ah7;
            if (a != b) {
                this.ah5 = a;
                this.wn("ValueAxisLabelVisibility", enumGetBox(Visibility_$type, b), enumGetBox(Visibility_$type, this.ah7));
            }
        }
        get_aba() {
            return this.aa9;
        }
        set_aba(a) {
            let b = this.aba;
            if (a != b) {
                this.aa9 = a;
                this.wn("ValueAxisLabelLocation", enumGetBox(ValueAxisLabelLocation_$type, b), enumGetBox(ValueAxisLabelLocation_$type, this.aba));
            }
        }
        get aba() {
            return this.get_aba();
        }
        set aba(a) {
            this.set_aba(a);
        }
        get_aa0() {
            return this.aaz;
        }
        set_aa0(a) {
            let b = this.aa0;
            if (a != b) {
                this.aaz = a;
                this.wn("AngleAxisLabelLocation", enumGetBox(AngleAxisLabelLocation_$type, b), enumGetBox(AngleAxisLabelLocation_$type, this.aa0));
            }
        }
        get aa0() {
            return this.get_aa0();
        }
        set aa0(a) {
            this.set_aa0(a);
        }
        get ad6() {
            return this.adr;
        }
        set ad6(a) {
            let b = this.adr;
            if (a != b) {
                this.adr = a;
                this.wn("AngleAxisLabelFormat", b, this.adr);
            }
        }
        get aax() {
            return this.aav;
        }
        set aax(a) {
            let b = this.aav;
            if (a != b) {
                this.aav = a;
                this.wn("AngleAxisLabelFormatSpecifiers", b, this.aav);
            }
        }
        get afe() {
            return this.adv;
        }
        set afe(a) {
            let b = this.adv;
            if (a != b) {
                this.adv = a;
                this.wn("ValueAxisLabelFormat", b, this.adv);
            }
        }
        get aay() {
            return this.aaw;
        }
        set aay(a) {
            let b = this.aaw;
            if (a != b) {
                this.aaw = a;
                this.wn("ValueAxisLabelFormatSpecifiers", b, this.aaw);
            }
        }
    }
    RadialBaseChart.$t = markType(RadialBaseChart, 'RadialBaseChart', DomainChart.$);
    return RadialBaseChart;
})();
