victory-core 37.0.1-next.2 → 37.0.2

package/es/victory-util/add-events.d.ts

@@ -1,127 +1,127 @@
-import React from "react";
-import { VictoryLabelableProps } from "../types/prop-types";
-import { VictoryCommonProps, VictoryDatableProps } from "./common-props";
-import type { ComponentEvent } from "./events";
-import * as Events from "./events";
-export declare type MixinOptions = {
-    components?: Array<{
-        name: string;
-        index?: string | number;
-    }>;
-};
-export interface EventMixinCommonProps extends VictoryCommonProps, VictoryDatableProps, VictoryLabelableProps {
-}
-/**
- * These methods will be implemented by the Mixin,
- * and are accessible to the Wrapped Component.
- *
- * To make your Wrapped Component type-safe, use "interface merging" like so:
- * @example
- *    interface MyComponent extends EventsMixinClass<MyProps> {}
- *    class MyComponent extends React.Component<MyProps> { ... }
- */
-export interface EventsMixinClass<TProps> {
-    renderContainer(component: React.ReactElement, children: React.ReactElement | React.ReactElement[]): React.ReactElement;
-    cacheValues<TThis>(this: TThis, obj: Partial<TThis>): void;
-    getEventState: typeof Events.getEventState;
-    renderData(props: TProps): any;
-    renderContinuousData(props: TProps): any;
-    animateComponent(props: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
-    getComponentProps(component: React.ReactNode, type: string, index: string | number): TProps;
-    dataKeys: string[];
-}
-/**
- * These fields are calculated by the Mixin
- */
-export interface EventMixinCalculatedValues {
-    componentEvents: Array<ComponentEvent>;
-    getSharedEventState: (key: string, value: string) => unknown;
-    baseProps: Record<string, object>;
-    dataKeys: string[];
-    hasEvents: unknown;
-    events: unknown;
-}
-/**
- * These are the common roles that we care about internally.
- */
-export declare type VictoryComponentCommonRole = "container" | "group" | "histogram" | "label" | "line" | "portal" | "stack" | "tooltip" | "voronoi";
-/**
- * A component can have any "role",
- * but there are certain ones that we actually care about internally
- */
-export declare type VictoryComponentRole = VictoryComponentCommonRole | string;
-/**
- * Static component fields used by Victory for common behavior
- */
-export interface VictoryComponentConfiguration<TProps> {
-    getBaseProps?(props: TProps): EventMixinCalculatedValues["baseProps"];
-    role?: VictoryComponentRole;
-    expectedComponents?: Array<keyof TProps | string>;
-    getChildren?: (props: TProps, childComponents?: Array<React.ReactNode>, calculatedProps?: TProps) => void;
-    animationWhitelist?: Array<keyof TProps | string>;
-}
-/**
- * This represents the class itself, including static fields
- */
-export interface WrappedComponentClass<TProps> extends VictoryComponentConfiguration<TProps> {
-    new (props: TProps): React.Component<TProps>;
-}
-export declare function addEvents<TBase extends WrappedComponentClass<TProps>, TProps extends EventMixinCommonProps>(WrappedComponent: TBase, options?: MixinOptions): {
-    new (props: TProps): {
-        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: TProps): 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): EventMixinCalculatedValues;
-        getExternalMutations(props: TProps): {} | 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: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
-        renderContinuousData(props: TProps): 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<TProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        render(): React.ReactNode;
-        readonly props: Readonly<TProps>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>): any;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
-        componentEvents: ComponentEvent[];
-        getSharedEventState: (key: string, value: string) => unknown;
-        baseProps: Record<string, object>;
-        dataKeys: string[];
-        hasEvents: unknown;
-        events: unknown;
-    };
-    getBaseProps?(props: TProps): Record<string, object>;
-    role?: string | undefined;
-    expectedComponents?: (string | keyof TProps)[] | undefined;
-    getChildren?: ((props: TProps, childComponents?: React.ReactNode[] | undefined, calculatedProps?: TProps | undefined) => void) | undefined;
-    animationWhitelist?: (string | keyof TProps)[] | undefined;
-} & TBase;
+import React from "react";
+import { VictoryLabelableProps } from "../types/prop-types";
+import { VictoryCommonProps, VictoryDatableProps } from "./common-props";
+import type { ComponentEvent } from "./events";
+import * as Events from "./events";
+export declare type MixinOptions = {
+    components?: Array<{
+        name: string;
+        index?: string | number;
+    }>;
+};
+export interface EventMixinCommonProps extends VictoryCommonProps, VictoryDatableProps, VictoryLabelableProps {
+}
+/**
+ * These methods will be implemented by the Mixin,
+ * and are accessible to the Wrapped Component.
+ *
+ * To make your Wrapped Component type-safe, use "interface merging" like so:
+ * @example
+ *    interface MyComponent extends EventsMixinClass<MyProps> {}
+ *    class MyComponent extends React.Component<MyProps> { ... }
+ */
+export interface EventsMixinClass<TProps> {
+    renderContainer(component: React.ReactElement, children: React.ReactElement | React.ReactElement[]): React.ReactElement;
+    cacheValues<TThis>(this: TThis, obj: Partial<TThis>): void;
+    getEventState: typeof Events.getEventState;
+    renderData(props: TProps): any;
+    renderContinuousData(props: TProps): any;
+    animateComponent(props: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
+    getComponentProps(component: React.ReactNode, type: string, index: string | number): TProps;
+    dataKeys: string[];
+}
+/**
+ * These fields are calculated by the Mixin
+ */
+export interface EventMixinCalculatedValues {
+    componentEvents: Array<ComponentEvent>;
+    getSharedEventState: (key: string, value: string) => unknown;
+    baseProps: Record<string, object>;
+    dataKeys: string[];
+    hasEvents: unknown;
+    events: unknown;
+}
+/**
+ * These are the common roles that we care about internally.
+ */
+export declare type VictoryComponentCommonRole = "container" | "group" | "histogram" | "label" | "line" | "portal" | "stack" | "tooltip" | "voronoi";
+/**
+ * A component can have any "role",
+ * but there are certain ones that we actually care about internally
+ */
+export declare type VictoryComponentRole = VictoryComponentCommonRole | string;
+/**
+ * Static component fields used by Victory for common behavior
+ */
+export interface VictoryComponentConfiguration<TProps> {
+    getBaseProps?(props: TProps): EventMixinCalculatedValues["baseProps"];
+    role?: VictoryComponentRole;
+    expectedComponents?: Array<keyof TProps | string>;
+    getChildren?: (props: TProps, childComponents?: Array<React.ReactNode>, calculatedProps?: TProps) => void;
+    animationWhitelist?: Array<keyof TProps | string>;
+}
+/**
+ * This represents the class itself, including static fields
+ */
+export interface WrappedComponentClass<TProps> extends VictoryComponentConfiguration<TProps> {
+    new (props: TProps): React.Component<TProps>;
+}
+export declare function addEvents<TBase extends WrappedComponentClass<TProps>, TProps extends EventMixinCommonProps>(WrappedComponent: TBase, options?: MixinOptions): {
+    new (props: TProps): {
+        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: TProps): 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): EventMixinCalculatedValues;
+        getExternalMutations(props: TProps): {} | 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: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
+        renderContinuousData(props: TProps): 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<TProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): React.ReactNode;
+        readonly props: Readonly<TProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
+        componentEvents: ComponentEvent[];
+        getSharedEventState: (key: string, value: string) => unknown;
+        baseProps: Record<string, object>;
+        dataKeys: string[];
+        hasEvents: unknown;
+        events: unknown;
+    };
+    getBaseProps?(props: TProps): Record<string, object>;
+    role?: string | undefined;
+    expectedComponents?: (string | keyof TProps)[] | undefined;
+    getChildren?: ((props: TProps, childComponents?: React.ReactNode[] | undefined, calculatedProps?: TProps | undefined) => void) | undefined;
+    animationWhitelist?: (string | keyof TProps)[] | undefined;
+} & TBase;
 //# sourceMappingURL=add-events.d.ts.map

package/es/victory-util/axis.d.ts

@@ -1,51 +1,51 @@
-import { D3Scale } from "../types/prop-types";
-/**
- * Returns the axis (x or y) of a particular axis component
- * @param {Object} props: the props object.
- * @param {Boolean} horizontal: true for horizontal charts
- * @returns {String} the dimension appropriate for the axis given its props
- */
-export declare function getAxis(props: any): "x" | "y";
-/**
- * Returns all axis components that pass a given predicate
- * @param {Array} childComponents: an array of children
- * @param {Function} predicate: a predicate function that will be called with each
- * @returns {Array} all axis components that pass the given predicate or []
- */
-export declare function findAxisComponents(childComponents: any, predicate?: any): any;
-/**
- * Returns a single axis component of the desired axis type (x or y)
- * @param {Array} childComponents: an array of children
- * @param {String} axis: desired axis either "x" or "y".
- * @returns {ReactComponent} an axis component of the desired axis or undefined
- */
-export declare function getAxisComponent(childComponents: any, axis: any): any;
-/**
- * Returns all axis components of the desired axis type (x or y) along with any
- * parent components excluding VictoryChart
- * @param {Array} childComponents: an optional array of children.
- * @param {String} type: desired axis either "dependent" or "independent".
- * @returns {ReactComponent} an axis component of the desired type or undefined
- */
-export declare function getAxisComponentsWithParent(childComponents: any, type: any): any;
-export declare function getOrigin(domain: any): {
-    x: number | Date;
-    y: number | Date;
-};
-export declare function getOriginSign(origin: any, domain: any): "positive" | "negative";
-/**
- * @param {Object} props: axis component props
- * @returns {Boolean} true when the axis is vertical
- */
-export declare function isVertical(props: any): any;
-/**
- * @param {Object} props: axis component props
- * @returns {Boolean} true when tickValues contain strings
- */
-export declare function stringTicks(props: any): boolean;
-export declare function getTickFormat(props: any, scale: any): any;
-export declare function getTicks(props: any, scale: D3Scale, filterZero?: boolean): number[] | string[];
-export declare function getDomain(props: any, axis?: any): any;
-export declare function getAxisValue(props: any, axis: any): any;
-export declare function modifyProps(props: any, fallbackProps: any): any;
+import { D3Scale } from "../types/prop-types";
+/**
+ * Returns the axis (x or y) of a particular axis component
+ * @param {Object} props: the props object.
+ * @param {Boolean} horizontal: true for horizontal charts
+ * @returns {String} the dimension appropriate for the axis given its props
+ */
+export declare function getAxis(props: any): "x" | "y";
+/**
+ * Returns all axis components that pass a given predicate
+ * @param {Array} childComponents: an array of children
+ * @param {Function} predicate: a predicate function that will be called with each
+ * @returns {Array} all axis components that pass the given predicate or []
+ */
+export declare function findAxisComponents(childComponents: any, predicate?: any): any;
+/**
+ * Returns a single axis component of the desired axis type (x or y)
+ * @param {Array} childComponents: an array of children
+ * @param {String} axis: desired axis either "x" or "y".
+ * @returns {ReactComponent} an axis component of the desired axis or undefined
+ */
+export declare function getAxisComponent(childComponents: any, axis: any): any;
+/**
+ * Returns all axis components of the desired axis type (x or y) along with any
+ * parent components excluding VictoryChart
+ * @param {Array} childComponents: an optional array of children.
+ * @param {String} type: desired axis either "dependent" or "independent".
+ * @returns {ReactComponent} an axis component of the desired type or undefined
+ */
+export declare function getAxisComponentsWithParent(childComponents: any, type: any): any;
+export declare function getOrigin(domain: any): {
+    x: number | Date;
+    y: number | Date;
+};
+export declare function getOriginSign(origin: any, domain: any): "positive" | "negative";
+/**
+ * @param {Object} props: axis component props
+ * @returns {Boolean} true when the axis is vertical
+ */
+export declare function isVertical(props: any): any;
+/**
+ * @param {Object} props: axis component props
+ * @returns {Boolean} true when tickValues contain strings
+ */
+export declare function stringTicks(props: any): boolean;
+export declare function getTickFormat(props: any, scale: any): any;
+export declare function getTicks(props: any, scale: D3Scale, filterZero?: boolean): number[] | string[];
+export declare function getDomain(props: any, axis?: any): any;
+export declare function getAxisValue(props: any, axis: any): any;
+export declare function modifyProps(props: any, fallbackProps: any): any;
 //# sourceMappingURL=axis.d.ts.map

package/es/victory-util/collection.d.ts

@@ -1,16 +1,16 @@
-export declare function containsStrings<T>(collection: Array<T>): boolean;
-export declare function containsDates(collection: Array<number | Date>): boolean;
-export declare function containsNumbers(collection: any): boolean;
-export declare function containsOnlyStrings(collection: Array<string> | unknown): collection is Array<string>;
-/**
- * Creates an array of array values not included in the other given arrays
- * @param a The array to inspect
- * @param b The values to exclude
- * @returns The new array of filtered values
- */
-export declare function difference<T>(a: Array<T>, b: Array<T>): Array<T>;
-export declare function isArrayOfArrays<T>(collection: Array<T> | Array<Array<T>> | unknown): collection is Array<Array<T>>;
-export declare function removeUndefined(arr: any): any;
-export declare function getMaxValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
-export declare function getMinValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
+export declare function containsStrings<T>(collection: Array<T>): boolean;
+export declare function containsDates(collection: Array<number | Date>): boolean;
+export declare function containsNumbers(collection: any): boolean;
+export declare function containsOnlyStrings(collection: Array<string> | unknown): collection is Array<string>;
+/**
+ * Creates an array of array values not included in the other given arrays
+ * @param a The array to inspect
+ * @param b The values to exclude
+ * @returns The new array of filtered values
+ */
+export declare function difference<T>(a: Array<T>, b: Array<T>): Array<T>;
+export declare function isArrayOfArrays<T>(collection: Array<T> | Array<Array<T>> | unknown): collection is Array<Array<T>>;
+export declare function removeUndefined(arr: any): any;
+export declare function getMaxValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
+export declare function getMinValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
 //# sourceMappingURL=collection.d.ts.map

package/es/victory-util/common-props.d.ts

@@ -1,80 +1,80 @@
-import * as React from "react";
-import { OriginType } from "../victory-label/victory-label";
-import { PaddingProps, VictoryThemeDefinition } from "../victory-theme/types";
-import { AnimatePropTypeInterface, CategoryPropType, ColorScalePropType, D3Scale, DataGetterPropType, DomainPaddingPropType, DomainPropType, EventCallbackInterface, RangePropType, ScalePropType, SortOrderPropType, StringOrNumberOrList } from "../types/prop-types";
-import { NumberOrCallback, StringOrCallback } from "../types/callbacks";
-export interface VictoryDatableProps {
-    categories?: CategoryPropType;
-    data?: readonly any[];
-    dataComponent?: React.ReactElement;
-    domain?: DomainPropType;
-    domainPadding?: DomainPaddingPropType;
-    samples?: number;
-    sortKey?: DataGetterPropType;
-    sortOrder?: SortOrderPropType;
-    x?: DataGetterPropType;
-    y?: DataGetterPropType;
-    y0?: DataGetterPropType;
-}
-export interface VictoryCommonThemeProps {
-    animate?: boolean | AnimatePropTypeInterface;
-    colorScale?: ColorScalePropType;
-    containerComponent?: React.ReactElement;
-    disableInlineStyles?: boolean;
-    domainPadding?: DomainPaddingPropType;
-    externalEventMutations?: EventCallbackInterface<string | string[], StringOrNumberOrList>[];
-    groupComponent?: React.ReactElement;
-    height?: number;
-    horizontal?: boolean;
-    maxDomain?: number | {
-        x?: number;
-        y?: number;
-    };
-    minDomain?: number | {
-        x?: number;
-        y?: number;
-    };
-    name?: string;
-    origin?: OriginType;
-    padding?: PaddingProps;
-    polar?: boolean;
-    range?: RangePropType;
-    scale?: ScalePropType | D3Scale | {
-        x?: ScalePropType | D3Scale;
-        y?: ScalePropType | D3Scale;
-    };
-    sharedEvents?: {
-        events: any[];
-        getEventState: Function;
-    };
-    singleQuadrantDomainPadding?: boolean | {
-        x?: boolean;
-        y?: boolean;
-    };
-    standalone?: boolean;
-    width?: number;
-}
-export interface VictoryCommonProps extends VictoryCommonThemeProps {
-    theme?: VictoryThemeDefinition;
-}
-export interface VictoryCommonPrimitiveProps {
-    active?: boolean;
-    ariaLabel?: StringOrCallback;
-    className?: string;
-    clipPath?: string;
-    data?: any;
-    desc?: string | Function;
-    disableInlineStyles?: boolean;
-    events?: object;
-    id?: number | string | Function;
-    index?: number | string;
-    origin?: OriginType;
-    polar?: boolean;
-    role?: string;
-    scale?: any;
-    shapeRendering?: string;
-    style?: any;
-    tabIndex?: NumberOrCallback;
-    transform?: string;
-}
+import * as React from "react";
+import { OriginType } from "../victory-label/victory-label";
+import { PaddingProps, VictoryThemeDefinition } from "../victory-theme/types";
+import { AnimatePropTypeInterface, CategoryPropType, ColorScalePropType, D3Scale, DataGetterPropType, DomainPaddingPropType, DomainPropType, EventCallbackInterface, RangePropType, ScalePropType, SortOrderPropType, StringOrNumberOrList } from "../types/prop-types";
+import { NumberOrCallback, StringOrCallback } from "../types/callbacks";
+export interface VictoryDatableProps {
+    categories?: CategoryPropType;
+    data?: readonly any[];
+    dataComponent?: React.ReactElement;
+    domain?: DomainPropType;
+    domainPadding?: DomainPaddingPropType;
+    samples?: number;
+    sortKey?: DataGetterPropType;
+    sortOrder?: SortOrderPropType;
+    x?: DataGetterPropType;
+    y?: DataGetterPropType;
+    y0?: DataGetterPropType;
+}
+export interface VictoryCommonThemeProps {
+    animate?: boolean | AnimatePropTypeInterface;
+    colorScale?: ColorScalePropType;
+    containerComponent?: React.ReactElement;
+    disableInlineStyles?: boolean;
+    domainPadding?: DomainPaddingPropType;
+    externalEventMutations?: EventCallbackInterface<string | string[], StringOrNumberOrList>[];
+    groupComponent?: React.ReactElement;
+    height?: number;
+    horizontal?: boolean;
+    maxDomain?: number | {
+        x?: number;
+        y?: number;
+    };
+    minDomain?: number | {
+        x?: number;
+        y?: number;
+    };
+    name?: string;
+    origin?: OriginType;
+    padding?: PaddingProps;
+    polar?: boolean;
+    range?: RangePropType;
+    scale?: ScalePropType | D3Scale | {
+        x?: ScalePropType | D3Scale;
+        y?: ScalePropType | D3Scale;
+    };
+    sharedEvents?: {
+        events: any[];
+        getEventState: Function;
+    };
+    singleQuadrantDomainPadding?: boolean | {
+        x?: boolean;
+        y?: boolean;
+    };
+    standalone?: boolean;
+    width?: number;
+}
+export interface VictoryCommonProps extends VictoryCommonThemeProps {
+    theme?: VictoryThemeDefinition;
+}
+export interface VictoryCommonPrimitiveProps {
+    active?: boolean;
+    ariaLabel?: StringOrCallback;
+    className?: string;
+    clipPath?: string;
+    data?: any;
+    desc?: string | Function;
+    disableInlineStyles?: boolean;
+    events?: object;
+    id?: number | string | Function;
+    index?: number | string;
+    origin?: OriginType;
+    polar?: boolean;
+    role?: string;
+    scale?: any;
+    shapeRendering?: string;
+    style?: any;
+    tabIndex?: NumberOrCallback;
+    transform?: string;
+}
 //# sourceMappingURL=common-props.d.ts.map