How to use the @hpcc-js/api.INDChart.prototype function in @hpcc-js/api

//  INDChart
    _palette;
    fillColor: (row, column, value) => string;
    strokeColor: (row, column, value) => string;
    textColor: (row, column, value) => string;
    dblclick: (row, column, selected) => void;

    //  ITooltip
    tooltip;
    tooltipHTML: (_) => string;
    tooltipFormat: (_) => string;
    tooltipStyle: () => "default" | "none" | "series-table";
}
Scatter.prototype._class += " chart_Scatter";
Scatter.prototype.implements(INDChart.prototype);
Scatter.prototype.implements(ITooltip.prototype);
export interface Scatter {
    valueAnchor(): string;
    valueAnchor(_: string): this;
    valueBaseline(): string;
    valueBaseline(_: string): this;
    showValue(): boolean;
    showValue(_: boolean): this;
    pointDarken(): boolean;
    pointDarken(_: boolean): this;
    interpolateDarken(): boolean;
    interpolateDarken(_: boolean): this;
}
Scatter.prototype.publish("paletteID", "default", "set", "Color palette for this widget", Scatter.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
Scatter.prototype.publish("pointSizeScale", "linear", "set", "pointSizeScale", ["linear", "pow", "log", "sqrt"]);
Scatter.prototype.publish("pointShape", "cross", "set", "Shape of the data points", ["circle", "rectangle", "cross"]);

paletteID: { (): string, (_: string): Area };
    stacked: { (): boolean, (_: boolean): Area };
    fillOpacity: { (): number, (_: number): Area };
    stackType: { (): string, (_: string): Area };

    bulletSize: { (): number, (_: number): Area };
    bulletType: { (): string, (_: string): Area };

    //  INDChart
    _palette;
    click: (row, column, selected) => void;
    dblclick: (row, column, selected) => void;
}
Area.prototype._class += " amchart_Area";
Area.prototype.implements(INDChart.prototype);

Area.prototype.publish("paletteID", "default", "set", "Palette ID", Area.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
Area.prototype.publish("stacked", false, "boolean", "Stack Chart", null, { tags: ["Basic", "Shared"] });
Area.prototype.publish("fillOpacity", 0.7, "number", "Opacity of The Fill Color", null, { min: 0, max: 1, step: 0.001, inputType: "range", tags: ["Intermediate", "Shared"] });
Area.prototype.publish("stackType", "regular", "set", "Stack Type", ["none", "regular", "100%"], { tags: ["Basic"] });

Area.prototype.publish("bulletSize", 6, "number", "Bullet Size", null, { tags: ["Intermediate"] });
Area.prototype.publish("bulletType", "round", "set", "Bullet Type", ["none", "round", "square", "triangleUp", "triangleDown", "triangleLeft", "triangleRight", "bubble", "diamond"], { tags: ["Basic"] });

//  INDChart
    _palette;
    fillColor: (row, column, value) => string;
    strokeColor: (row, column, value) => string;
    textColor: (row, column, value) => string;
    click: (row, column, selected) => void;
    dblclick: (row, column, selected) => void;

    //  ITooltip
    tooltip;
    tooltipHTML: (_) => string;
    tooltipFormat: (_) => string;
    _selection;
}
RadialBar.prototype._class += " chart_RadialBar";
RadialBar.prototype.implements(INDChart.prototype);
RadialBar.prototype.implements(ITooltip.prototype);
RadialBar.prototype.mixin(Utility.SimpleSelectionMixin);
export interface RadialBar {
    paletteID(): string;
    paletteID(_: string): this;
    tickCount(): number;
    tickCount(_: number): this;
    domainPadding(): number;
    domainPadding(_: number): this;
    valueMaxAngle(): number;
    valueMaxAngle(_: number): this;
    valueDomainHigh(): number;
    valueDomainHigh(_: number): this;
    valueDomainHigh_exists(): boolean;
    transitionDelay(): number;
    transitionDelay(_: number): this;

fillOpacity_exists: () => boolean;
    stackType: { (): string; (_: string): Combo };
    stackType_exists: () => boolean;
    bulletSize: { (): number; (_: number): Combo };
    bulletSize_exists: () => boolean;
    bulletType: { (): string; (_: string): Combo };
    bulletType_exists: () => boolean;
    defaultType: { (): string; (_: string): Combo };
    defaultType_exists: () => boolean;
    types: { (): any[]; (_: any[]): Combo };
    types_exists: () => boolean;
    charts: { (): any[]; (_: any[]): Combo };
    charts_exists: () => boolean;
}
Combo.prototype._class += " amchart_Combo";
Combo.prototype.implements(INDChart.prototype);

Combo.prototype.publish("paletteID", "default", "set", "Palette ID", Combo.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
Combo.prototype.publish("stacked", false, "boolean", "Stack Chart", null, { tags: ["Basic", "Shared"] });
Combo.prototype.publish("fillOpacity", 0.2, "number", "Opacity of The Fill Color", null, { min: 0, max: 1, step: 0.001, inputType: "range", tags: ["Intermediate", "Shared"] });
Combo.prototype.publish("stackType", "regular", "set", "Stack Type", ["none", "regular", "100%"], { tags: ["Basic"] });

Combo.prototype.publish("bulletSize", 6, "number", "Bullet Size", null, { tags: ["Intermediate"] });
Combo.prototype.publish("bulletType", "round", "set", "Bullet Type", ["none", "round", "square", "triangleUp", "triangleDown", "triangleLeft", "triangleRight", "bubble", "diamond"], { tags: ["Basic"] });

Combo.prototype.publish("defaultType", "column", "set", "Default chart type", ["column", "line", "spline", "area", "area-spline", "step", "area-step", "scatter"], { tags: ["Basic"] });
Combo.prototype.publish("types", [], "array", "Array of chart types (ex:bar|line|spline|area|area-spline|step|area-step|scatter)", null, { tags: ["Basic"] });

Combo.prototype.publish("charts", [], "widgetArray", "widgets", null, { tags: ["Basic"] }); // perhaps we want to load up the params on a chart and pass in the chart and just read the params there?

_palette;
    fillColor: (row, column, value) => string;
    strokeColor: (row, column, value) => string;
    textColor: (row, column, value) => string;
    click: (row, column, selected) => void;
    dblclick: (row, column, selected) => void;

    //  ITooltip
    tooltip;
    tooltipHTML: (_) => string;
    tooltipFormat: (_) => string;

    _selection;
}
Radar.prototype._class += " chart_Radar";
Radar.prototype.implements(INDChart.prototype);
Radar.prototype.implements(ITooltip.prototype);
Radar.prototype.mixin(Utility.SimpleSelectionMixin);

export interface Radar {
    labelPaddingRatio(): number;
    labelPaddingRatio(_: number): this;
    fillOpacity(): number;
    fillOpacity(_: number): this;
    fontFamily(): string;
    fontFamily(_: string): this;
    fontSize(): number;
    fontSize(_: number): this;
    valueGuideRatios(): any;
    valueGuideRatios(_: any): this;
    valueGuideFontSize(): number;
    valueGuideFontSize(_: number): this;

}

    //  INDChart  ---
    _palette;
    fillColor: (row, column, value) => string;
    textColor: (row, column, value) => string;
    dblclick: (row, column, selected) => void;

    //  ITooltip  ---
    tooltip;
    tooltipHTML: (_) => string;
    tooltipFormat: (_) => string;
    tooltipStyle: () => "default" | "none" | "series-table";
}
Column.prototype._class += " chart_Column";
Column.prototype.implements(INDChart.prototype);
Column.prototype.implements(ITooltip.prototype);

export interface Column {
    paletteID(): string;
    paletteID(_: string): this;
    useClonedPalette(): boolean;
    useClonedPalette(_: boolean): this;
    showValue(): boolean;
    showValue(_: boolean): this;
    showValueFormat(): string;
    showValueFormat(_: string): this;
    showValueAsPercent(): null | "series" | "domain";
    showValueAsPercent(_: null | "series" | "domain"): this;
    showValueAsPercentFormat(): string;
    showValueAsPercentFormat(_: string): this;
    valueCentered(): boolean;

return gObj;
        }
    }

    update(domNode, element) {
        CommonRadar.prototype.update.apply(this, arguments);
        this.updateChartOptions();

        this._chart.validateNow();
        this._chart.validateData();
    }
    paletteID: { (): string; (_: string): Polar };
    paletteID_exists: () => boolean;
}
Polar.prototype._class += " amchart_Polar";
Polar.prototype.implements(INDChart.prototype);

Polar.prototype.publish("paletteID", "default", "set", "Palette ID", Polar.prototype._palette.switch(), { tags: ["Basic", "Shared"] });

update(domNode, element) {
        this._palette = this._palette.switch(this.paletteID());
        if (this.useClonedPalette()) {
            this._palette = this._palette.cloneNotExists(this.paletteID() + "_" + this.id());
        }
        Common.prototype.update.apply(this, arguments);
    }

    paletteID: { (): string; (_: string): CommonND };
    paletteID_exists: () => boolean;
    useClonedPalette: { (): boolean; (_: boolean): CommonND };
    useClonedPalette_exists: () => boolean;
}
CommonND.prototype._class += " google_CommonND";
CommonND.prototype.implements(INDChart.prototype);

CommonND.prototype.publish("paletteID", "default", "set", "Palette ID", CommonND.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
CommonND.prototype.publish("useClonedPalette", false, "boolean", "Enable or disable using a cloned palette", null, { tags: ["Intermediate", "Shared"] });

function initSeries(num) {
    const series = [];
    for (let i = 0; i < num; i++) {
        series.push({});
    }
    return series;
}

CommonXY.prototype.update.apply(this, arguments);

        this.updateChartOptions();

        this._chart.validateNow();
        this._chart.validateData();

    }

    paletteID: { (): string; (_: string): Scatter };
    paletteID_exists: () => boolean;
    scatterType: { (): string; (_: string): Scatter };
    scatterType_exists: () => boolean;
}
Scatter.prototype._class += " amchart_Scatter";
Scatter.prototype.implements(INDChart.prototype);

Scatter.prototype.publish("paletteID", "default", "set", "Palette ID", Scatter.prototype._palette.switch(), { tags: ["Basic", "Shared"] });

Scatter.prototype.publish("scatterType", "scatter", "set", "Bullet Type", ["scatter", "bubble"], { tags: ["Basic"] });