victory-axis/lib/victory-axis.d.ts

Axis Component for Victory

import React from "react";
import { Axis, EventPropTypeInterface, OrientationTypes, VictoryAxisCommonProps, VictoryCommonProps, VictorySingleLabelableProps, EventsMixinClass } from "victory-core";
export type VictoryAxisTTargetType = "axis" | "axisLabel" | "grid" | "ticks" | "tickLabels" | "parent";
export interface VictoryAxisProps extends VictoryAxisCommonProps, VictoryCommonProps, VictorySingleLabelableProps {
    crossAxis?: boolean;
    events?: EventPropTypeInterface<VictoryAxisTTargetType, number | string>[];
    fixLabelOverlap?: boolean;
    offsetX?: number;
    offsetY?: number;
    orientation?: OrientationTypes;
}
interface VictoryAxisBase extends EventsMixinClass<VictoryAxisProps> {
}
declare class VictoryAxisBase extends React.Component<VictoryAxisProps> {
    static animationWhitelist: Array<keyof VictoryAxisProps>;
    static displayName: string;
    static role: string;
    static defaultTransitions: {
        onExit: {
            duration: number;
        };
        onEnter: {
            duration: number;
        };
    };
    static defaultProps: {
        axisComponent: JSX.Element;
        axisLabelComponent: JSX.Element;
        tickLabelComponent: JSX.Element;
        tickComponent: JSX.Element;
        gridComponent: JSX.Element;
        standalone: boolean;
        theme: import("victory-core").VictoryThemeDefinition;
        containerComponent: JSX.Element;
        groupComponent: JSX.Element;
        fixLabelOverlap: boolean;
    };
    static getDomain: typeof Axis.getDomain;
    static getAxis: typeof Axis.getAxis;
    static getStyles(props: any): {
        parent: any;
        axis: any;
        axisLabel: any;
        grid: any;
        ticks: any;
        tickLabels: any;
    };
    static getBaseProps(props: any): {
        parent: {
            style: any;
            ticks: number[] | string[];
            standalone: any;
            theme: any;
            width: any;
            height: any;
            padding: any;
            domain: {
                x: any;
                y: any;
            };
        } & {
            scale: {
                [x: string]: import("victory-core").D3Scale<any> | undefined;
            };
            polar: any;
            horizontal: any;
            ticks: number[] | string[];
            stringTicks: any;
        };
    };
    static expectedComponents: Array<keyof VictoryAxisProps>;
    renderLine(props: any): React.FunctionComponentElement<{
        crossAxis: boolean;
        events: EventPropTypeInterface<VictoryAxisTTargetType, number | string>[];
        fixLabelOverlap: boolean;
        offsetX: number;
        offsetY: number;
        orientation: "top" | "bottom" | "left" | "right";
        axisComponent: React.ReactElement;
        axisLabelComponent: React.ReactElement;
        axisValue: number | string | object | Date;
        dependentAxis: boolean;
        domain: import("victory-core").Tuple<number> | import("victory-core").Tuple<Date> | {
            x?: import("victory-core").DomainTuple | undefined;
            y?: import("victory-core").DomainTuple | undefined;
        };
        gridComponent: React.ReactElement;
        invertAxis: boolean;
        style: {
            parent?: import("victory-core").VictoryStyleObject;
            axis?: import("victory-core").VictoryStyleObject;
            axisLabel?: import("victory-core").VictoryLabelStyleObject | import("victory-core").VictoryLabelStyleObject[];
            grid?: import("victory-core").VictoryStyleObject;
            ticks?: import("victory-core").VictoryTickStyleObject;
            tickLabels?: import("victory-core").VictoryLabelStyleObject | import("victory-core").VictoryLabelStyleObject[];
        };
        tickComponent: React.ReactElement;
        tickCount: number;
        tickLabelComponent: React.ReactElement;
        tickFormat: any[] | {
            (tick: any, index: number, ticks: any[]): string | number;
        };
        tickValues: any[];
        theme: import("victory-core").VictoryThemeDefinition;
        animate: boolean | import("victory-core").AnimatePropTypeInterface;
        colorScale: string[] | "grayscale" | "qualitative" | "heatmap" | "warm" | "cool" | "red" | "green" | "blue";
        containerComponent: React.ReactElement;
        disableInlineStyles: boolean;
        domainPadding: number | import("victory-core").Tuple<number> | {
            x?: import("victory-core").PaddingType | undefined;
            y?: import("victory-core").PaddingType | undefined;
        };
        externalEventMutations: import("victory-core").EventCallbackInterface<string | string[], import("victory-core").StringOrNumberOrList>[];
        groupComponent: React.ReactElement;
        height: number;
        horizontal: boolean;
        maxDomain: number | {
            x?: number;
            y?: number;
        };
        minDomain: number | {
            x?: number;
            y?: number;
        };
        name: string;
        origin: import("victory-core").OriginType;
        padding: number | import("victory-core").BlockProps;
        polar: boolean;
        range: import("victory-core").RangeTuple | {
            x?: import("victory-core").RangeTuple | undefined;
            y?: import("victory-core").RangeTuple | undefined;
        };
        scale: import("victory-core").D3Scale<any> | "linear" | "time" | "log" | "sqrt" | {
            x?: import("victory-core").ScalePropType | import("victory-core").D3Scale;
            y?: import("victory-core").ScalePropType | import("victory-core").D3Scale;
        };
        sharedEvents: {
            events: any[];
            getEventState: Function;
        };
        singleQuadrantDomainPadding: boolean | {
            x?: boolean;
            y?: boolean;
        };
        standalone: boolean;
        width: number;
        label: string | {
            (data: any): string | number | null;
        };
        labelComponent: React.ReactElement;
    }>;
    renderLabel(props: any): React.FunctionComponentElement<{
        crossAxis: boolean;
        events: EventPropTypeInterface<VictoryAxisTTargetType, number | string>[];
        fixLabelOverlap: boolean;
        offsetX: number;
        offsetY: number;
        orientation: "top" | "bottom" | "left" | "right";
        axisComponent: React.ReactElement;
        axisLabelComponent: React.ReactElement;
        axisValue: number | string | object | Date;
        dependentAxis: boolean;
        domain: import("victory-core").Tuple<number> | import("victory-core").Tuple<Date> | {
            x?: import("victory-core").DomainTuple | undefined;
            y?: import("victory-core").DomainTuple | undefined;
        };
        gridComponent: React.ReactElement;
        invertAxis: boolean;
        style: {
            parent?: import("victory-core").VictoryStyleObject;
            axis?: import("victory-core").VictoryStyleObject;
            axisLabel?: import("victory-core").VictoryLabelStyleObject | import("victory-core").VictoryLabelStyleObject[];
            grid?: import("victory-core").VictoryStyleObject;
            ticks?: import("victory-core").VictoryTickStyleObject;
            tickLabels?: import("victory-core").VictoryLabelStyleObject | import("victory-core").VictoryLabelStyleObject[];
        };
        tickComponent: React.ReactElement;
        tickCount: number;
        tickLabelComponent: React.ReactElement;
        tickFormat: any[] | {
            (tick: any, index: number, ticks: any[]): string | number;
        };
        tickValues: any[];
        theme: import("victory-core").VictoryThemeDefinition;
        animate: boolean | import("victory-core").AnimatePropTypeInterface;
        colorScale: string[] | "grayscale" | "qualitative" | "heatmap" | "warm" | "cool" | "red" | "green" | "blue";
        containerComponent: React.ReactElement;
        disableInlineStyles: boolean;
        domainPadding: number | import("victory-core").Tuple<number> | {
            x?: import("victory-core").PaddingType | undefined;
            y?: import("victory-core").PaddingType | undefined;
        };
        externalEventMutations: import("victory-core").EventCallbackInterface<string | string[], import("victory-core").StringOrNumberOrList>[];
        groupComponent: React.ReactElement;
        height: number;
        horizontal: boolean;
        maxDomain: number | {
            x?: number;
            y?: number;
        };
        minDomain: number | {
            x?: number;
            y?: number;
        };
        name: string;
        origin: import("victory-core").OriginType;
        padding: number | import("victory-core").BlockProps;
        polar: boolean;
        range: import("victory-core").RangeTuple | {
            x?: import("victory-core").RangeTuple | undefined;
            y?: import("victory-core").RangeTuple | undefined;
        };
        scale: import("victory-core").D3Scale<any> | "linear" | "time" | "log" | "sqrt" | {
            x?: import("victory-core").ScalePropType | import("victory-core").D3Scale;
            y?: import("victory-core").ScalePropType | import("victory-core").D3Scale;
        };
        sharedEvents: {
            events: any[];
            getEventState: Function;
        };
        singleQuadrantDomainPadding: boolean | {
            x?: boolean;
            y?: boolean;
        };
        standalone: boolean;
        width: number;
        label: string | {
            (data: any): string | number | null;
        };
        labelComponent: React.ReactElement;
    }> | null;
    renderGridAndTicks(props: any): React.FunctionComponentElement<{
        key: string;
    }>[];
    fixLabelOverlap(gridAndTicks: any, props: any): any;
    shouldAnimate(): boolean;
    render(): React.ReactElement;
}
export declare const VictoryAxis: {
    new (props: import("victory-core").EventMixinCommonProps): {
        state: {};
        getEventState: (eventKey: string | number, namespace: string, childType?: string | undefined) => any;
        getScopedEvents: (events: any, namespace: any, childType: any, baseProps: any) => {};
        getEvents: (p: any, target: any, eventKey: any) => any;
        externalMutations: {} | undefined;
        calculatedState: {};
        globalEvents: {};
        prevGlobalEventKeys: string[];
        boundGlobalEvents: {};
        shouldComponentUpdate(nextProps: import("victory-core").EventMixinCommonProps): boolean;
        componentDidMount(): void;
        componentDidUpdate(prevProps: any): void;
        componentWillUnmount(): void;
        addGlobalListener(key: any): void;
        removeGlobalListener(key: any): void;
        getStateChanges(props: any): {};
        applyExternalMutations(props: any, externalMutations: any): void;
        getCalculatedValues(props: any): import("victory-core").EventMixinCalculatedValues;
        getExternalMutations(props: import("victory-core").EventMixinCommonProps): {} | undefined;
        cacheValues(obj: any): void;
        getBaseProps(props: any, getSharedEventState: any): Record<string, object>;
        getAllEvents(props: any): any;
        getComponentProps(component: React.ReactNode, type: string, index: string | number): any;
        renderContainer(component: any, children: any): React.DetailedReactHTMLElement<any, HTMLElement>;
        animateComponent(props: import("victory-core").EventMixinCommonProps, defaultAnimationWhitelist: string[]): React.ReactElement;
        renderContinuousData(props: import("victory-core").EventMixinCommonProps): React.DetailedReactHTMLElement<any, HTMLElement>;
        renderData(props: any, shouldRenderDatum?: (datum: any) => boolean): React.DetailedReactHTMLElement<any, HTMLElement>;
        context: unknown;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("victory-core").EventMixinCommonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        render(): React.ReactNode;
        readonly props: Readonly<import("victory-core").EventMixinCommonProps>;
        refs: {
            [key: string]: React.ReactInstance;
        };
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(prevProps: Readonly<import("victory-core").EventMixinCommonProps>, prevState: Readonly<{}>): any;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextContext: any): void;
        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextContext: any): void;
        componentWillUpdate?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextState: Readonly<{}>, nextContext: any): void;
        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextState: Readonly<{}>, nextContext: any): void;
        componentEvents: Array<import("@/victory-core/lib/victory-util/events").ComponentEvent>;
        getSharedEventState: (key: string, value: string) => unknown;
        baseProps: Record<string, object>;
        dataKeys: string[];
        hasEvents: unknown;
        events: unknown;
    };
    getBaseProps?(props: import("victory-core").EventMixinCommonProps): import("victory-core").EventMixinCalculatedValues["baseProps"];
    role?: import("victory-core").VictoryComponentRole;
    expectedComponents?: string[] | undefined;
    getChildren?: ((props: import("victory-core").EventMixinCommonProps, childComponents?: Array<React.ReactNode>, calculatedProps?: import("victory-core").EventMixinCommonProps | undefined) => void) | undefined;
    animationWhitelist?: string[] | undefined;
} & typeof VictoryAxisBase;
export {};
//# sourceMappingURL=victory-axis.d.ts.map