igniteui-react-charts/lib/CategoryBucketCalculator_combined.d.ts

Ignite UI React charting components for building rich data visualizations using TypeScript APIs.

import { Base, Type, Point } from "igniteui-react-core";
import { IBucketizer } from "./IBucketizer";
import { IFastItemColumn$1 } from "igniteui-react-core";
import { Rect } from "igniteui-react-core";
import { CategoryAxisBase } from "./CategoryAxisBase";
import { ScalerParams } from "./ScalerParams";
import { SeriesView } from "./SeriesView";
import { Axis } from "./Axis";
import { FramePreparer } from "./FramePreparer";
import { IIsCategoryBased } from "./IIsCategoryBased";
import { List$1 } from "igniteui-react-core";
import { ISupportsMarkers } from "./ISupportsMarkers";
import { IProvidesViewport } from "./IProvidesViewport";
import { ISupportsErrorBars } from "./ISupportsErrorBars";
import { CategoryFrame } from "./CategoryFrame";
import { IDetectsCollisions } from "./IDetectsCollisions";
import { PreparationParams } from "./PreparationParams";
import { Frame } from "./Frame";
import { ICategoryScaler } from "./ICategoryScaler";
import { ValuesHolder } from "./ValuesHolder";
import { NumericAxisBase } from "./NumericAxisBase";
import { IHasCategoryTrendline } from "./IHasCategoryTrendline";
import { IHasSingleValueCategory } from "./IHasSingleValueCategory";
import { MarkerSeries } from "./MarkerSeries";
import { IHasCategoryModePreference } from "./IHasCategoryModePreference";
import { ICategorySeriesInteractionManager } from "./ICategorySeriesInteractionManager";
import { CategoryCollisionMode } from "./CategoryCollisionMode";
import { CategoryTransitionInMode } from "./CategoryTransitionInMode";
import { HighlightingInfo } from "igniteui-react-core";
import { CategoryTransitionSourceFramePreparer } from "./CategoryTransitionSourceFramePreparer";
import { SeriesPointOfInterest } from "./SeriesPointOfInterest";
import { Marker } from "./Marker";
import { MarkerSeriesView } from "./MarkerSeriesView";
import { CategoryMode } from "./CategoryMode";
import { CategorySeriesRenderManager } from "./CategorySeriesRenderManager";
import { AssigningCategoryStyleEventArgs } from "./AssigningCategoryStyleEventArgs";
import { AssigningCategoryMarkerStyleEventArgs } from "./AssigningCategoryMarkerStyleEventArgs";
import { SeriesComponentsForView } from "./SeriesComponentsForView";
import { Pool$1 } from "igniteui-react-core";
import { TransitionInSpeedType } from "./TransitionInSpeedType";
import { TransitionOutSpeedType } from "./TransitionOutSpeedType";
import { SeriesLayerPropertyOverlay } from "./SeriesLayerPropertyOverlay";
import { RenderSurface } from "./RenderSurface";
import { Clipper } from "igniteui-react-core";
import { ChartSelection } from "./ChartSelection";
import { SeriesSelectionBehavior } from "./SeriesSelectionBehavior";
import { ValueCollisionMode } from "./ValueCollisionMode";
/**
 * @hidden
 */
export declare class CategoryBucketCalculator extends Base implements IBucketizer {
    static $t: Type;
    protected c: CategorySeriesView;
    constructor(a: CategorySeriesView);
    e: number;
    f: number;
    d: number;
    getBucket(a: number): number[];
    getBucketWithoutUnknowns(a: number): number[];
    getErrorBucket(a: number, b: IFastItemColumn$1<number>): number;
    g(a: number): void;
    getBucketInfo(a: number, b: number, c: number, d: number): {
        p0: number;
        p1: number;
        p2: number;
        p3: number;
    };
    cacheValues(): void;
    unCacheValues(): void;
}
/**
 * @hidden
 */
export declare abstract class CategoryFramePreparerBase extends FramePreparer {
    static $t: Type;
    constructor(a: number, b: IIsCategoryBased);
    constructor(a: number, b: IIsCategoryBased, c: ISupportsMarkers, d: IProvidesViewport, e: ISupportsErrorBars, f: IBucketizer);
    constructor(a: number, ..._rest: any[]);
    g: IBucketizer;
    h: IIsCategoryBased;
    protected abstract l(a: CategoryFrame, b: number[], c: IDetectsCollisions, d: number, e: number, f: number): boolean;
    m: boolean;
    i(a: Frame): PreparationParams;
    r(a: ICategoryScaler, b: Rect, c: Rect, d: Rect): number;
    s(a: PreparationParams): number;
    d(a: Frame, b: SeriesView): void;
    protected v(a: CategoryFrame, b: SeriesView, c: PreparationParams): void;
    private o;
    protected get q(): List$1<number[]>;
    private p;
    private n;
    protected t(a: PreparationParams, b: ValuesHolder, c: number, d: boolean, e: boolean): number;
    protected k(): boolean;
    protected abstract z(a: ValuesHolder, b: number, c: boolean, d: boolean): void;
    protected abstract u(a: ValuesHolder, b: number, c: boolean): void;
    protected abstract e(a: number, b: ValuesHolder): number[];
    protected f(a: PreparationParams, b: number, c: ValuesHolder, d: number, e: boolean, f: number[], g: number): {
        ret: number[];
        p1?: number;
        p4: boolean;
        p5: number[];
    };
    protected y(a: PreparationParams, b: number, c: boolean, d: ScalerParams, e: ScalerParams, f: boolean, g: boolean): void;
    protected abstract x(a: PreparationParams, b: number[], c: number, d: boolean, e: ScalerParams, f: ScalerParams): void;
    protected w(a: PreparationParams, b: ValuesHolder, c: number): void;
    abstract j(a: PreparationParams): ValuesHolder;
}
/**
 * @hidden
 */
export declare class CategoryFramePreparer extends CategoryFramePreparerBase {
    static $t: Type;
    constructor(a: number, b: IIsCategoryBased);
    constructor(a: number, b: IIsCategoryBased, c: ISupportsMarkers, d: IProvidesViewport, e: ISupportsErrorBars, f: IBucketizer);
    constructor(a: number, ..._rest: any[]);
    private aa;
    private ab;
    protected ac: IHasCategoryTrendline;
    protected ad: IHasSingleValueCategory;
    protected l(a: CategoryFrame, b: number[], c: IDetectsCollisions, d: number, e: number, f: number): boolean;
    j(a: PreparationParams): ValuesHolder;
    protected x(a: PreparationParams, b: number[], c: number, d: boolean, e: ScalerParams, f: ScalerParams): void;
    protected y(a: PreparationParams, b: number, c: boolean, d: ScalerParams, e: ScalerParams, f: boolean, g: boolean): void;
    protected w(a: PreparationParams, b: ValuesHolder, c: number): void;
    protected z(a: ValuesHolder, b: number, c: boolean, d: boolean): void;
    protected u(a: ValuesHolder, b: number, c: boolean): void;
    protected e(a: number, b: ValuesHolder): number[];
}
/**
 * @hidden
 */
export declare abstract class CategorySeries extends MarkerSeries implements IHasCategoryModePreference, ISupportsErrorBars {
    static $t: Type;
    zk: CategoryFramePreparer;
    protected ct(): SeriesView;
    zo: CategorySeriesView;
    private zs;
    get zt(): ICategorySeriesInteractionManager;
    ed(a: List$1<SeriesPointOfInterest>, b: boolean, c: boolean, d: number, e: boolean): boolean;
    private aak;
    rh(a: SeriesView): void;
    preferredCategoryMode(a: CategoryAxisBase): CategoryMode;
    get categoryAxis(): CategoryAxisBase;
    zd(): CategoryAxisBase;
    zu(): NumericAxisBase;
    protected get_em(): boolean;
    protected get_gb(): boolean;
    protected get_e1(): boolean;
    constructor();
    ac(): void;
    z5: boolean;
    z4: boolean;
    ze: CategoryCollisionMode;
    protected z1: boolean;
    protected z0: boolean;
    assigningCategoryStyle: (sender: any, args: AssigningCategoryStyleEventArgs) => void;
    assigningCategoryMarkerStyle: (sender: any, args: AssigningCategoryMarkerStyleEventArgs) => void;
    z7(): boolean;
    protected z8(): boolean;
    protected aa7(a: AssigningCategoryStyleEventArgs): void;
    protected aa6(a: AssigningCategoryMarkerStyleEventArgs): void;
    y7(a: number, b: number): any[];
    pi(a: boolean, b: SeriesView): void;
    bs(): SeriesComponentsForView;
    qp(): void;
    aab: boolean;
    protected s9(a: Rect, b: Rect): void;
    zq: CategoryTransitionInMode;
    z6: boolean;
    protected s8(a: Rect, b: Rect): void;
    protected rq(a: any, b: string, c: any, d: any): void;
    protected z3(): boolean;
    protected z2(): boolean;
    aae(a: Point): number;
    protected get_fv(): boolean;
    a0(): CategoryAxisBase;
    ke(a: Point): number;
    abstract getOffsetValue(): number;
    abstract getCategoryWidth(): number;
    kw(a: Point): any;
    kc(a: Point): number;
    iy(a: Point): number;
    private zy;
    private zz;
    di(a: any, b: Point, c: boolean): HighlightingInfo;
    protected get_fh(): boolean;
    pg(): void;
    dh(a: any, b: Point, c: boolean): HighlightingInfo;
    protected aad(): List$1<Marker>;
    protected zx(a: any, b: Point, c: HighlightingInfo): HighlightingInfo;
    protected zw(a: any, b: Point, c: HighlightingInfo): HighlightingInfo;
    protected zv(a: any, b: Point, c: HighlightingInfo): HighlightingInfo;
    zh: CategoryFrame;
    zj: CategoryFrame;
    zf: CategoryFrame;
    zi: CategoryFrame;
    zg(): CategoryFrame;
    zn: CategorySeriesRenderManager;
    protected aa3(a: List$1<number[]>, b: number, c: number, d: CategoryAxisBase, e: ScalerParams, f: boolean, g: number): void;
    aa4(a: List$1<number[]>, b: number, c: number, d: CategoryAxisBase, e: ScalerParams, f: boolean, g: number): void;
    hk(a: Rect, b: Rect, c: SeriesView): boolean;
    private aac;
    protected gt(): boolean;
    protected gu(): boolean;
    protected zp(): CategoryTransitionInMode;
    zr: CategoryTransitionSourceFramePreparer;
    protected pj(): void;
    r9(a: boolean): void;
    protected c5(): TransitionInSpeedType;
    protected c8(): TransitionOutSpeedType;
    protected aaf(): number;
    protected z9(): boolean;
    protected hz(): List$1<SeriesLayerPropertyOverlay>;
    k4(): any;
    aaj(): number;
    get GetErrorBarsXAxis(): Axis;
    get GetErrorBarsYAxis(): Axis;
    aau(a: CategorySeriesView, b: CategoryFrame): void;
    aa8(a: CategoryFrame, b: CategorySeriesView): void;
    aa5(a: CategoryFrame, b: CategorySeriesView): void;
    aag(a: SeriesView): number;
    aah(a: SeriesView): number;
    aai(a: SeriesView): number;
    aat(a: SeriesView): void;
    sa(a: Rect, b: RenderSurface): void;
    sb(): void;
    abstract fetchXAxis(): Axis;
    abstract fetchYAxis(): Axis;
    abstract aaa(): boolean;
    zl(a: CategorySeriesView): CategoryFramePreparer;
    aw(a: Axis): Axis;
    ai(): Axis[];
    static y8(a: List$1<number[]>, b: number, c: Rect, d: Rect, e: boolean): Clipper;
    aa0(a: Rect, b: List$1<ChartSelection>, c: SeriesSelectionBehavior, d: CategoryCollisionMode, e: ValueCollisionMode): void;
    aa2(a: List$1<ChartSelection>, b: number, c: number, d: SeriesSelectionBehavior): void;
    abstract aa1(a: ValueCollisionMode, b: List$1<ChartSelection>, c: number, d: number, e: number, f: number, g: SeriesSelectionBehavior): void;
    abstract aas(a: List$1<ChartSelection>, b: number, c: SeriesSelectionBehavior): void;
    aav(a: Rect, b: NumericAxisBase, c: boolean, d: Rect, e: number, f: number): {
        p4: number;
        p5: number;
    };
    aaw(a: Rect, b: CategoryAxisBase, c: boolean, d: Rect, e: number, f: number): {
        p4: number;
        p5: number;
    };
    aax(a: CategoryAxisBase, b: number, c: number, d: number, e: number): {
        p3: number;
        p4: number;
    };
    aaz(a: CategoryAxisBase, b: number, c: number, d: number, e: number): {
        p3: number;
        p4: number;
    };
    aay(a: CategoryAxisBase, b: number, c: number, d: number, e: number): {
        p3: number;
        p4: number;
    };
    static $$p: string[];
}
/**
 * @hidden
 */
export declare class CategorySeriesView extends MarkerSeriesView implements ISupportsMarkers {
    static $t: Type;
    db: CategorySeries;
    de: number;
    dd(a: CategoryFrame): boolean;
    dg(a: CategoryFrame): void;
    constructor(a: CategorySeries);
    updateMarkerTemplate(a: number, b: number, c: number): void;
    c9: CategoryBucketCalculator;
    da(): CategoryBucketCalculator;
    dc: Pool$1<Marker>;
    get shouldDisplayMarkers(): boolean;
    updateMarkerCount(a: number): void;
    cw(a: (arg1: Marker) => void): void;
    df(): void;
}